Skip to content

widgets module

widgets module.

contains QtWidgets-based classes

__all__ = ['app', 'Application', 'AbstractSlider', 'AbstractSliderMixin', 'AbstractButton', 'AbstractButtonMixin', 'AbstractSpinBox', 'AbstractSpinBoxMixin', 'AbstractScrollArea', 'AbstractScrollAreaMixin', 'AbstractItemView', 'AbstractItemViewMixin', 'MdiSubWindow', 'MdiArea', 'ScrollBar', 'ScrollArea', 'Widget', 'WidgetMixin', 'RubberBand', 'GraphicsTransform', 'GraphicsTransformMixin', 'GraphicsRotation', 'GraphicsScale', 'GraphicsItem', 'GraphicsItemMixin', 'GraphicsItemGroup', 'AbstractGraphicsShapeItem', 'AbstractGraphicsShapeItemMixin', 'GraphicsPixmapItem', 'GraphicsObject', 'GraphicsObjectMixin', 'GraphicsTextItem', 'GraphicsLayoutItem', 'GraphicsLayoutItemMixin', 'GraphicsLayout', 'GraphicsLayoutMixin', 'GraphicsGridLayout', 'GraphicsAnchorLayout', 'GraphicsLinearLayout', 'GraphicsWidget', 'GraphicsWidgetMixin', 'GraphicsProxyWidget', 'GraphicsLineItem', 'GraphicsRectItem', 'GraphicsSimpleTextItem', 'GraphicsPolygonItem', 'GraphicsEllipseItem', 'GraphicsPathItem', 'GraphicsWidget', 'GraphicsEffect', 'GraphicsEffectMixin', 'GraphicsBlurEffect', 'GraphicsDropShadowEffect', 'GraphicsColorizeEffect', 'GraphicsOpacityEffect', 'GraphicsScene', 'GraphicsView', 'GraphicsViewMixin', 'Style', 'StyleMixin', 'CommonStyle', 'CommonStyleMixin', 'ProxyStyle', 'StyleOption', 'StyleOptionMixin', 'StyleOptionComplex', 'StyleOptionComplexMixin', 'SpacerItem', 'SizePolicy', 'StylePainter', 'StyleFactory', 'Dialog', 'DialogMixin', 'MessageBox', 'ErrorMessage', 'FileIconProvider', 'FileSystemModel', 'LayoutItem', 'LayoutItemMixin', 'WidgetItem', 'Layout', 'LayoutMixin', 'FormLayout', 'BoxLayout', 'StackedLayout', 'GridLayout', 'ToolBox', 'Slider', 'Dial', 'StyleOptionButton', 'StyleOptionDockWidget', 'StyleOptionFocusRect', 'StyleOptionGraphicsItem', 'StyleOptionHeader', 'StyleOptionMenuItem', 'StyleOptionProgressBar', 'StyleOptionRubberBand', 'StyleOptionTab', 'StyleOptionTabBarBase', 'StyleOptionTabWidgetFrame', 'StyleOptionToolBar', 'StyleOptionToolBox', 'StyleOptionViewItem', 'StyleOptionComboBox', 'StyleOptionGroupBox', 'StyleOptionSizeGrip', 'StyleOptionSlider', 'StyleOptionSpinBox', 'StyleOptionTitleBar', 'StyleOptionToolButton', 'StyleOptionFrame', 'Frame', 'FrameMixin', 'FocusFrame', 'ListWidgetItem', 'TreeWidgetItem', 'TreeWidgetItemIterator', 'Action', 'ActionMixin', 'ActionGroup', 'WidgetAction', 'ToolButton', 'ToolTip', 'Menu', 'MenuBar', 'StatusBar', 'TabWidget', 'TabBar', 'ToolBar', 'HeaderView', 'DockWidget', 'Label', 'PushButton', 'PushButtonMixin', 'CommandLinkButton', 'RadioButton', 'ComboBox', 'ComboBoxMixin', 'FontComboBox', 'SpinBox', 'DoubleSpinBox', 'CheckBox', 'LineEdit', 'KeySequenceEdit', 'TextEdit', 'TextEditMixin', 'DateEdit', 'TimeEdit', 'DateTimeEdit', 'DateTimeEditMixin', 'CalendarWidget', 'PlainTextEdit', 'PlainTextEditMixin', 'TextBrowser', 'Completer', 'ProgressBar', 'LCDNumber', 'ColumnView', 'ListView', 'ListViewMixin', 'ListWidget', 'TreeView', 'TreeViewMixin', 'TreeWidget', 'TableWidgetSelectionRange', 'ScrollerProperties', 'Scroller', 'TableView', 'TableViewMixin', 'TableWidgetItem', 'TableWidget', 'SplashScreen', 'ProgressDialog', 'FontDialog', 'FileDialog', 'ColorDialog', 'InputDialog', 'DialogButtonBox', 'ButtonGroup', 'GroupBox', 'SplitterHandle', 'Splitter', 'Wizard', 'WizardPage', 'StackedWidget', 'MainWindow', 'Shortcut', 'WhatsThis', 'AbstractItemDelegate', 'AbstractItemDelegateMixin', 'ItemDelegate', 'StyledItemDelegate', 'SystemTrayIcon', 'UndoView', 'DataWidgetMapper', 'SizeGrip', 'KeyEventTransition', 'MouseEventTransition', 'GraphicsSceneHoverEvent', 'GraphicsSceneMouseEvent', 'GraphicsSceneWheelEvent', 'GraphicsSceneContextMenuEvent', 'GraphicsSceneDragDropEvent', 'GraphicsSceneHelpEvent', 'GraphicsSceneMoveEvent', 'GraphicsSceneResizeEvent', 'GraphicsSceneEvent', 'GestureEvent', 'PlainTextDocumentLayout', 'Gesture', 'GestureMixin', 'TapGesture', 'TapAndHoldGesture', 'PanGesture', 'PinchGesture', 'SwipeGesture', 'ItemEditorFactory', 'ItemEditorCreatorBase'] module-attribute

AbstractButton

Bases: AbstractButtonMixin, QtWidgets.QAbstractButton

Source code in prettyqt\widgets\abstractbutton.py
class AbstractButton(AbstractButtonMixin, QtWidgets.QAbstractButton):
    pass

AbstractButtonMixin

Bases: widgets.WidgetMixin

Source code in prettyqt\widgets\abstractbutton.py
class AbstractButtonMixin(widgets.WidgetMixin):
    def __bool__(self):
        return self.isChecked()

    def set_icon(self, icon: datatypes.IconType):
        """Set the icon for the button.

        Args:
            icon: icon to use
        """
        icon = iconprovider.get_icon(icon)
        self.setIcon(icon)

    def get_icon(self) -> gui.Icon | None:
        icon = self.icon()
        return None if icon.isNull() else gui.Icon(icon)

    def set_style_icon(self, icon: widgets.style.StandardPixmapStr, size: int = 15):
        """Set theme icon for the button.

        Args:
            icon: icon to use
            size: icon size
        """
        if icon not in widgets.style.STANDARD_PIXMAP:
            raise InvalidParamError(icon, widgets.style.STANDARD_PIXMAP)
        qicon = self.style().standardIcon(widgets.style.STANDARD_PIXMAP[icon], None, self)
        self.set_icon(qicon)
        self.setIconSize(core.Size(size, size))

    def set_shortcut(self, shortcut: None | QtGui.QKeySequence | str):
        if shortcut is None:
            shortcut = ""
        if isinstance(shortcut, str):
            shortcut = gui.KeySequence(
                shortcut, gui.KeySequence.SequenceFormat.PortableText
            )
        self.setShortcut(shortcut)

    def get_shortcut(self) -> gui.KeySequence:
        return gui.KeySequence(
            self.shortcut().toString(), gui.KeySequence.SequenceFormat.PortableText
        )

    def set_text(self, text: str):
        self.setText(text)

    def set_icon_size(self, size: int | datatypes.SizeType):
        """Set size of the icon."""
        if isinstance(size, int):
            size = core.Size(size, size)
        elif isinstance(size, tuple):
            size = core.Size(*size)
        self.setIconSize(size)

    def get_icon_size(self) -> core.Size:
        return core.Size(self.iconSize())

    def get_value(self) -> bool:
        return self.isChecked()

    def set_value(self, value: bool):
        self.setChecked(value)

    @property
    def is_on(self) -> bool:
        return self.isChecked()

    @is_on.setter
    def is_on(self, state: bool):
        self.setChecked(state)

is_on: bool writable property

__bool__()

Source code in prettyqt\widgets\abstractbutton.py
def __bool__(self):
    return self.isChecked()

get_icon() -> gui.Icon | None

Source code in prettyqt\widgets\abstractbutton.py
def get_icon(self) -> gui.Icon | None:
    icon = self.icon()
    return None if icon.isNull() else gui.Icon(icon)

get_icon_size() -> core.Size

Source code in prettyqt\widgets\abstractbutton.py
def get_icon_size(self) -> core.Size:
    return core.Size(self.iconSize())

get_shortcut() -> gui.KeySequence

Source code in prettyqt\widgets\abstractbutton.py
def get_shortcut(self) -> gui.KeySequence:
    return gui.KeySequence(
        self.shortcut().toString(), gui.KeySequence.SequenceFormat.PortableText
    )

get_value() -> bool

Source code in prettyqt\widgets\abstractbutton.py
def get_value(self) -> bool:
    return self.isChecked()

set_icon(icon: datatypes.IconType)

Set the icon for the button.

Parameters:

Name Type Description Default
icon datatypes.IconType

icon to use

required
Source code in prettyqt\widgets\abstractbutton.py
def set_icon(self, icon: datatypes.IconType):
    """Set the icon for the button.

    Args:
        icon: icon to use
    """
    icon = iconprovider.get_icon(icon)
    self.setIcon(icon)

set_icon_size(size: int | datatypes.SizeType)

Set size of the icon.

Source code in prettyqt\widgets\abstractbutton.py
def set_icon_size(self, size: int | datatypes.SizeType):
    """Set size of the icon."""
    if isinstance(size, int):
        size = core.Size(size, size)
    elif isinstance(size, tuple):
        size = core.Size(*size)
    self.setIconSize(size)

set_shortcut(shortcut: None | QtGui.QKeySequence | str)

Source code in prettyqt\widgets\abstractbutton.py
def set_shortcut(self, shortcut: None | QtGui.QKeySequence | str):
    if shortcut is None:
        shortcut = ""
    if isinstance(shortcut, str):
        shortcut = gui.KeySequence(
            shortcut, gui.KeySequence.SequenceFormat.PortableText
        )
    self.setShortcut(shortcut)

set_style_icon(icon: widgets.style.StandardPixmapStr, size: int = 15)

Set theme icon for the button.

Parameters:

Name Type Description Default
icon widgets.style.StandardPixmapStr

icon to use

required
size int

icon size

15
Source code in prettyqt\widgets\abstractbutton.py
def set_style_icon(self, icon: widgets.style.StandardPixmapStr, size: int = 15):
    """Set theme icon for the button.

    Args:
        icon: icon to use
        size: icon size
    """
    if icon not in widgets.style.STANDARD_PIXMAP:
        raise InvalidParamError(icon, widgets.style.STANDARD_PIXMAP)
    qicon = self.style().standardIcon(widgets.style.STANDARD_PIXMAP[icon], None, self)
    self.set_icon(qicon)
    self.setIconSize(core.Size(size, size))

set_text(text: str)

Source code in prettyqt\widgets\abstractbutton.py
def set_text(self, text: str):
    self.setText(text)

set_value(value: bool)

Source code in prettyqt\widgets\abstractbutton.py
def set_value(self, value: bool):
    self.setChecked(value)

AbstractGraphicsShapeItem

Bases: AbstractGraphicsShapeItemMixin, QtWidgets.QAbstractGraphicsShapeItem

Source code in prettyqt\widgets\abstractgraphicsshapeitem.py
class AbstractGraphicsShapeItem(
    AbstractGraphicsShapeItemMixin, QtWidgets.QAbstractGraphicsShapeItem
):
    pass

AbstractGraphicsShapeItemMixin

Bases: widgets.GraphicsItemMixin

Source code in prettyqt\widgets\abstractgraphicsshapeitem.py
class AbstractGraphicsShapeItemMixin(widgets.GraphicsItemMixin):
    pass

AbstractItemDelegate

Bases: AbstractItemDelegateMixin, QtWidgets.QAbstractItemDelegate

Source code in prettyqt\widgets\abstractitemdelegate.py
class AbstractItemDelegate(AbstractItemDelegateMixin, QtWidgets.QAbstractItemDelegate):
    pass

AbstractItemDelegateMixin

Bases: core.ObjectMixin

Source code in prettyqt\widgets\abstractitemdelegate.py
class AbstractItemDelegateMixin(core.ObjectMixin):
    pass

AbstractItemView

Bases: AbstractItemViewMixin, QtWidgets.QAbstractItemView

Source code in prettyqt\widgets\abstractitemview.py
class AbstractItemView(AbstractItemViewMixin, QtWidgets.QAbstractItemView):
    pass

AbstractItemViewMixin

Bases: widgets.AbstractScrollAreaMixin

Source code in prettyqt\widgets\abstractitemview.py
class AbstractItemViewMixin(widgets.AbstractScrollAreaMixin):
    model_changed = core.Signal(QtCore.QAbstractItemModel)

    def __len__(self) -> int:
        return model.rowCount() if (model := self.model()) is not None else 0

    def selectAll(self):
        """Override, we dont want to selectAll for too many items bc of performance."""
        if self.model() is None:
            return
        if self.model().rowCount() * self.model().columnCount() > 1_000_000:
            logger.warning("Too many cells to select.")
            return
        super().selectAll()

    def set_model(self, model: QtCore.QAbstractItemModel | None):
        """Delete old selection model explicitely, seems to help with memory usage."""
        old_model = self.model()
        old_sel_model = self.selectionModel()
        if old_model is not None or model is not None:
            self.setModel(model)  # type: ignore
            self.model_changed.emit(model)
        # if old_model:
        #     old_model.deleteLater()
        #     del old_model
        if old_sel_model:
            old_sel_model.deleteLater()
            del old_sel_model

    def set_delegate(
        self,
        delegate: QtWidgets.QAbstractItemDelegate,
        column: int | None = None,
        row: int | None = None,
        persistent: bool = False,
    ):
        if column is not None:
            self.setItemDelegateForColumn(column, delegate)
            if persistent:
                model = self.model()
                for i in range(model.rowCount()):
                    index = model.index(i, column)
                    self.openPersistentEditor(index)
        elif row is not None:
            self.setItemDelegateForRow(row, delegate)
            if persistent:
                model = self.model()
                for i in range(model.columnCount()):
                    self.openPersistentEditor(model.index(row, i))
        else:
            self.setItemDelegate(delegate)

    def toggle_select_all(self):
        """Select all items from list (deselect when all selected)."""
        if self.selectionModel() is None:
            return
        if self.selectionModel().hasSelection():
            self.clearSelection()
        else:
            self.selectAll()

    def set_table_color(self, color: str):
        with self.edit_stylesheet() as ss:
            ss.QHeaderView.section.backgroundColor.setValue(color)

    def current_index(self) -> QtCore.QModelIndex | None:
        if (model := self.selectionModel()) is not None:
            return model.currentIndex()

    def current_data(self):
        if (model := self.selectionModel()) is not None:
            idx = model.currentIndex()
            return idx.data(constants.USER_ROLE)  # type: ignore

    def current_row(self) -> int | None:
        if (model := self.selectionModel()) is not None:
            return model.currentIndex().row()

    def current_column(self) -> int | None:
        if (model := self.selectionModel()) is not None:
            return model.currentIndex().column()

    def selected_indexes(self) -> list[QtCore.QModelIndex]:
        """Return list of selected indexes in first row."""
        indexes = (x for x in self.selectedIndexes() if x.column() == 0)  # type: ignore
        return sorted(indexes, key=lambda x: x.row())  # type: ignore

    def selected_names(self) -> Generator[Any, None, None]:
        """Return generator yielding item names."""
        return (x.data(constants.NAME_ROLE) for x in self.selected_indexes())

    def selected_rows(self) -> Generator[int, None, None]:
        """Return generator yielding row nums."""
        return (x.row() for x in self.selected_indexes())

    def selected_data(self) -> Generator[Any, None, None]:
        """Return generator yielding selected userData."""
        return (
            x.data(constants.USER_ROLE) for x in self.selected_indexes()  # type: ignore
        )

    def setup_dragdrop_move(self):
        self.setDragEnabled(True)
        self.setAcceptDrops(True)
        self.setDragDropMode(self.DragDropMode.DragDrop)
        self.setDefaultDropAction(constants.MOVE_ACTION)
        self.setDropIndicatorShown(True)

    def set_edit_triggers(self, *triggers: EditTriggerStr | None):
        items = ["none" if t is None else t for t in triggers]
        for item in items:
            if item not in EDIT_TRIGGERS:
                raise InvalidParamError(item, EDIT_TRIGGERS)
        flags = helpers.merge_flags(items, EDIT_TRIGGERS)
        self.setEditTriggers(flags)

    def get_edit_triggers(self) -> list[EditTriggerStr]:
        return EDIT_TRIGGERS.get_list(self.editTriggers())

    def set_selection_behaviour(self, behaviour: SelectionBehaviourStr):
        """Set selection behaviour for given item view.

        Args:
            behaviour: selection behaviour to use

        Raises:
            InvalidParamError: behaviour does not exist
        """
        if behaviour not in SELECTION_BEHAVIOUR:
            raise InvalidParamError(behaviour, SELECTION_BEHAVIOUR)
        self.setSelectionBehavior(SELECTION_BEHAVIOUR[behaviour])

    def get_selection_behaviour(self) -> SelectionBehaviourStr:
        """Return current selection behaviour.

        Returns:
            selection behaviour
        """
        return SELECTION_BEHAVIOUR.inverse[self.selectionBehavior()]

    def set_drag_drop_mode(self, mode: DragDropModeStr):
        """Set drag-drop mode for given item view.

        Args:
            mode: drag-drop mode to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode not in DRAG_DROP_MODE:
            raise InvalidParamError(mode, DRAG_DROP_MODE)
        self.setDragDropMode(DRAG_DROP_MODE[mode])

    def get_drag_drop_mode(self) -> DragDropModeStr:
        """Return current drag-drop mode.

        Returns:
            drag-drop mode
        """
        return DRAG_DROP_MODE.inverse[self.dragDropMode()]

    def set_selection_mode(self, mode: SelectionModeStr | None):
        """Set selection mode for given item view.

        Args:
            mode: selection mode to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode is None:
            mode = "none"
        if mode not in SELECTION_MODE:
            raise InvalidParamError(mode, SELECTION_MODE)
        self.setSelectionMode(SELECTION_MODE[mode])

    def get_selection_mode(self) -> SelectionModeStr:
        """Return current selection mode.

        Returns:
            selection mode
        """
        return SELECTION_MODE.inverse[self.selectionMode()]

    def set_scroll_mode(self, mode: ScrollModeStr):
        """Set the scroll mode for both directions.

        Args:
            mode: mode to set

        Raises:
            InvalidParamError: invalid scroll mode
        """
        if mode not in SCROLL_MODE:
            raise InvalidParamError(mode, SCROLL_MODE)
        self.setHorizontalScrollMode(SCROLL_MODE[mode])
        self.setVerticalScrollMode(SCROLL_MODE[mode])

    def set_horizontal_scroll_mode(self, mode: ScrollModeStr):
        """Set the horizontal scroll mode.

        Args:
            mode: mode to set

        Raises:
            InvalidParamError: invalid scroll mode
        """
        if mode not in SCROLL_MODE:
            raise InvalidParamError(mode, SCROLL_MODE)
        self.setHorizontalScrollMode(SCROLL_MODE[mode])

    def get_horizontal_scroll_mode(self) -> ScrollModeStr:
        """Return current horizontal scroll mode.

        Returns:
            horizontal scroll mode
        """
        return SCROLL_MODE.inverse[self.horizontalScrollMode()]

    def set_vertical_scroll_mode(self, mode: ScrollModeStr):
        """Set the vertical scroll mode.

        Args:
            mode: mode to set

        Raises:
            InvalidParamError: invalid scroll mode
        """
        if mode not in SCROLL_MODE:
            raise InvalidParamError(mode, SCROLL_MODE)
        self.setVerticalScrollMode(SCROLL_MODE[mode])

    def get_vertical_scroll_mode(self) -> ScrollModeStr:
        """Return current vertical scroll mode.

        Returns:
            vertical scroll mode
        """
        return SCROLL_MODE.inverse[self.verticalScrollMode()]

    def num_selected(self) -> int:
        """Return amount of selected rows.

        Returns:
            amount of selected rows
        """
        if (model := self.selectionModel()) is not None:
            return len(model.selectedRows())
        return 0

    def jump_to_column(self, col_num: int):
        """Make sure column at given index is visible.

        scrolls to column at given index

        Args:
            col_num: column to scroll to
        """
        if (model := self.model()) is not None:
            idx = model.index(0, col_num)
            self.scrollTo(idx)

    def scroll_to_top(self):
        """Override to use abstractitemview-way of scrolling to top."""
        self.scrollToTop()

    def scroll_to_bottom(self):
        """Override to use abstractitemview-way of scrolling to bottom."""
        self.scrollToBottom()

    def select_last_row(self):
        idx = self.model().createIndex(self.model().rowCount() - 1, 0)
        self.setCurrentIndex(idx)

    def scroll_to(self, index, mode: ScrollHintStr = "ensure_visible"):
        if mode not in SCROLL_HINT:
            raise InvalidParamError(mode, SCROLL_HINT)
        self.scrollTo(index, SCROLL_HINT[mode])

    def highlight_when_inactive(self):
        """Highlight items when widget does not have focus."""
        p = gui.Palette()
        p.highlight_inactive()
        self.setPalette(p)

    def set_icon_size(self, size: int | datatypes.SizeType):
        if isinstance(size, tuple):
            size = QtCore.QSize(*size)
        elif isinstance(size, int):
            size = QtCore.QSize(size, size)
        self.setIconSize(size)

model_changed = core.Signal(QtCore.QAbstractItemModel) class-attribute

__len__() -> int

Source code in prettyqt\widgets\abstractitemview.py
def __len__(self) -> int:
    return model.rowCount() if (model := self.model()) is not None else 0

current_column() -> int | None

Source code in prettyqt\widgets\abstractitemview.py
def current_column(self) -> int | None:
    if (model := self.selectionModel()) is not None:
        return model.currentIndex().column()

current_data()

Source code in prettyqt\widgets\abstractitemview.py
def current_data(self):
    if (model := self.selectionModel()) is not None:
        idx = model.currentIndex()
        return idx.data(constants.USER_ROLE)  # type: ignore

current_index() -> QtCore.QModelIndex | None

Source code in prettyqt\widgets\abstractitemview.py
def current_index(self) -> QtCore.QModelIndex | None:
    if (model := self.selectionModel()) is not None:
        return model.currentIndex()

current_row() -> int | None

Source code in prettyqt\widgets\abstractitemview.py
def current_row(self) -> int | None:
    if (model := self.selectionModel()) is not None:
        return model.currentIndex().row()

get_drag_drop_mode() -> DragDropModeStr

Return current drag-drop mode.

Returns:

Type Description
DragDropModeStr

drag-drop mode

Source code in prettyqt\widgets\abstractitemview.py
def get_drag_drop_mode(self) -> DragDropModeStr:
    """Return current drag-drop mode.

    Returns:
        drag-drop mode
    """
    return DRAG_DROP_MODE.inverse[self.dragDropMode()]

get_edit_triggers() -> list[EditTriggerStr]

Source code in prettyqt\widgets\abstractitemview.py
def get_edit_triggers(self) -> list[EditTriggerStr]:
    return EDIT_TRIGGERS.get_list(self.editTriggers())

get_horizontal_scroll_mode() -> ScrollModeStr

Return current horizontal scroll mode.

Returns:

Type Description
ScrollModeStr

horizontal scroll mode

Source code in prettyqt\widgets\abstractitemview.py
def get_horizontal_scroll_mode(self) -> ScrollModeStr:
    """Return current horizontal scroll mode.

    Returns:
        horizontal scroll mode
    """
    return SCROLL_MODE.inverse[self.horizontalScrollMode()]

get_selection_behaviour() -> SelectionBehaviourStr

Return current selection behaviour.

Returns:

Type Description
SelectionBehaviourStr

selection behaviour

Source code in prettyqt\widgets\abstractitemview.py
def get_selection_behaviour(self) -> SelectionBehaviourStr:
    """Return current selection behaviour.

    Returns:
        selection behaviour
    """
    return SELECTION_BEHAVIOUR.inverse[self.selectionBehavior()]

get_selection_mode() -> SelectionModeStr

Return current selection mode.

Returns:

Type Description
SelectionModeStr

selection mode

Source code in prettyqt\widgets\abstractitemview.py
def get_selection_mode(self) -> SelectionModeStr:
    """Return current selection mode.

    Returns:
        selection mode
    """
    return SELECTION_MODE.inverse[self.selectionMode()]

get_vertical_scroll_mode() -> ScrollModeStr

Return current vertical scroll mode.

Returns:

Type Description
ScrollModeStr

vertical scroll mode

Source code in prettyqt\widgets\abstractitemview.py
def get_vertical_scroll_mode(self) -> ScrollModeStr:
    """Return current vertical scroll mode.

    Returns:
        vertical scroll mode
    """
    return SCROLL_MODE.inverse[self.verticalScrollMode()]

highlight_when_inactive()

Highlight items when widget does not have focus.

Source code in prettyqt\widgets\abstractitemview.py
def highlight_when_inactive(self):
    """Highlight items when widget does not have focus."""
    p = gui.Palette()
    p.highlight_inactive()
    self.setPalette(p)

jump_to_column(col_num: int)

Make sure column at given index is visible.

scrolls to column at given index

Parameters:

Name Type Description Default
col_num int

column to scroll to

required
Source code in prettyqt\widgets\abstractitemview.py
def jump_to_column(self, col_num: int):
    """Make sure column at given index is visible.

    scrolls to column at given index

    Args:
        col_num: column to scroll to
    """
    if (model := self.model()) is not None:
        idx = model.index(0, col_num)
        self.scrollTo(idx)

num_selected() -> int

Return amount of selected rows.

Returns:

Type Description
int

amount of selected rows

Source code in prettyqt\widgets\abstractitemview.py
def num_selected(self) -> int:
    """Return amount of selected rows.

    Returns:
        amount of selected rows
    """
    if (model := self.selectionModel()) is not None:
        return len(model.selectedRows())
    return 0

scroll_to(index, mode: ScrollHintStr = 'ensure_visible')

Source code in prettyqt\widgets\abstractitemview.py
def scroll_to(self, index, mode: ScrollHintStr = "ensure_visible"):
    if mode not in SCROLL_HINT:
        raise InvalidParamError(mode, SCROLL_HINT)
    self.scrollTo(index, SCROLL_HINT[mode])

scroll_to_bottom()

Override to use abstractitemview-way of scrolling to bottom.

Source code in prettyqt\widgets\abstractitemview.py
def scroll_to_bottom(self):
    """Override to use abstractitemview-way of scrolling to bottom."""
    self.scrollToBottom()

scroll_to_top()

Override to use abstractitemview-way of scrolling to top.

Source code in prettyqt\widgets\abstractitemview.py
def scroll_to_top(self):
    """Override to use abstractitemview-way of scrolling to top."""
    self.scrollToTop()

selectAll()

Override, we dont want to selectAll for too many items bc of performance.

Source code in prettyqt\widgets\abstractitemview.py
def selectAll(self):
    """Override, we dont want to selectAll for too many items bc of performance."""
    if self.model() is None:
        return
    if self.model().rowCount() * self.model().columnCount() > 1_000_000:
        logger.warning("Too many cells to select.")
        return
    super().selectAll()

select_last_row()

Source code in prettyqt\widgets\abstractitemview.py
def select_last_row(self):
    idx = self.model().createIndex(self.model().rowCount() - 1, 0)
    self.setCurrentIndex(idx)

selected_data() -> Generator[Any, None, None]

Return generator yielding selected userData.

Source code in prettyqt\widgets\abstractitemview.py
def selected_data(self) -> Generator[Any, None, None]:
    """Return generator yielding selected userData."""
    return (
        x.data(constants.USER_ROLE) for x in self.selected_indexes()  # type: ignore
    )

selected_indexes() -> list[QtCore.QModelIndex]

Return list of selected indexes in first row.

Source code in prettyqt\widgets\abstractitemview.py
def selected_indexes(self) -> list[QtCore.QModelIndex]:
    """Return list of selected indexes in first row."""
    indexes = (x for x in self.selectedIndexes() if x.column() == 0)  # type: ignore
    return sorted(indexes, key=lambda x: x.row())  # type: ignore

selected_names() -> Generator[Any, None, None]

Return generator yielding item names.

Source code in prettyqt\widgets\abstractitemview.py
def selected_names(self) -> Generator[Any, None, None]:
    """Return generator yielding item names."""
    return (x.data(constants.NAME_ROLE) for x in self.selected_indexes())

selected_rows() -> Generator[int, None, None]

Return generator yielding row nums.

Source code in prettyqt\widgets\abstractitemview.py
def selected_rows(self) -> Generator[int, None, None]:
    """Return generator yielding row nums."""
    return (x.row() for x in self.selected_indexes())

set_delegate(delegate: QtWidgets.QAbstractItemDelegate, column: int | None = None, row: int | None = None, persistent: bool = False)

Source code in prettyqt\widgets\abstractitemview.py
def set_delegate(
    self,
    delegate: QtWidgets.QAbstractItemDelegate,
    column: int | None = None,
    row: int | None = None,
    persistent: bool = False,
):
    if column is not None:
        self.setItemDelegateForColumn(column, delegate)
        if persistent:
            model = self.model()
            for i in range(model.rowCount()):
                index = model.index(i, column)
                self.openPersistentEditor(index)
    elif row is not None:
        self.setItemDelegateForRow(row, delegate)
        if persistent:
            model = self.model()
            for i in range(model.columnCount()):
                self.openPersistentEditor(model.index(row, i))
    else:
        self.setItemDelegate(delegate)

set_drag_drop_mode(mode: DragDropModeStr)

Set drag-drop mode for given item view.

Parameters:

Name Type Description Default
mode DragDropModeStr

drag-drop mode to use

required

Raises:

Type Description
InvalidParamError

mode does not exist

Source code in prettyqt\widgets\abstractitemview.py
def set_drag_drop_mode(self, mode: DragDropModeStr):
    """Set drag-drop mode for given item view.

    Args:
        mode: drag-drop mode to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode not in DRAG_DROP_MODE:
        raise InvalidParamError(mode, DRAG_DROP_MODE)
    self.setDragDropMode(DRAG_DROP_MODE[mode])

set_edit_triggers(*triggers: EditTriggerStr | None)

Source code in prettyqt\widgets\abstractitemview.py
def set_edit_triggers(self, *triggers: EditTriggerStr | None):
    items = ["none" if t is None else t for t in triggers]
    for item in items:
        if item not in EDIT_TRIGGERS:
            raise InvalidParamError(item, EDIT_TRIGGERS)
    flags = helpers.merge_flags(items, EDIT_TRIGGERS)
    self.setEditTriggers(flags)

set_horizontal_scroll_mode(mode: ScrollModeStr)

Set the horizontal scroll mode.

Parameters:

Name Type Description Default
mode ScrollModeStr

mode to set

required

Raises:

Type Description
InvalidParamError

invalid scroll mode

Source code in prettyqt\widgets\abstractitemview.py
def set_horizontal_scroll_mode(self, mode: ScrollModeStr):
    """Set the horizontal scroll mode.

    Args:
        mode: mode to set

    Raises:
        InvalidParamError: invalid scroll mode
    """
    if mode not in SCROLL_MODE:
        raise InvalidParamError(mode, SCROLL_MODE)
    self.setHorizontalScrollMode(SCROLL_MODE[mode])

set_icon_size(size: int | datatypes.SizeType)

Source code in prettyqt\widgets\abstractitemview.py
def set_icon_size(self, size: int | datatypes.SizeType):
    if isinstance(size, tuple):
        size = QtCore.QSize(*size)
    elif isinstance(size, int):
        size = QtCore.QSize(size, size)
    self.setIconSize(size)

set_model(model: QtCore.QAbstractItemModel | None)

Delete old selection model explicitely, seems to help with memory usage.

Source code in prettyqt\widgets\abstractitemview.py
def set_model(self, model: QtCore.QAbstractItemModel | None):
    """Delete old selection model explicitely, seems to help with memory usage."""
    old_model = self.model()
    old_sel_model = self.selectionModel()
    if old_model is not None or model is not None:
        self.setModel(model)  # type: ignore
        self.model_changed.emit(model)
    # if old_model:
    #     old_model.deleteLater()
    #     del old_model
    if old_sel_model:
        old_sel_model.deleteLater()
        del old_sel_model

set_scroll_mode(mode: ScrollModeStr)

Set the scroll mode for both directions.

Parameters:

Name Type Description Default
mode ScrollModeStr

mode to set

required

Raises:

Type Description
InvalidParamError

invalid scroll mode

Source code in prettyqt\widgets\abstractitemview.py
def set_scroll_mode(self, mode: ScrollModeStr):
    """Set the scroll mode for both directions.

    Args:
        mode: mode to set

    Raises:
        InvalidParamError: invalid scroll mode
    """
    if mode not in SCROLL_MODE:
        raise InvalidParamError(mode, SCROLL_MODE)
    self.setHorizontalScrollMode(SCROLL_MODE[mode])
    self.setVerticalScrollMode(SCROLL_MODE[mode])

set_selection_behaviour(behaviour: SelectionBehaviourStr)

Set selection behaviour for given item view.

Parameters:

Name Type Description Default
behaviour SelectionBehaviourStr

selection behaviour to use

required

Raises:

Type Description
InvalidParamError

behaviour does not exist

Source code in prettyqt\widgets\abstractitemview.py
def set_selection_behaviour(self, behaviour: SelectionBehaviourStr):
    """Set selection behaviour for given item view.

    Args:
        behaviour: selection behaviour to use

    Raises:
        InvalidParamError: behaviour does not exist
    """
    if behaviour not in SELECTION_BEHAVIOUR:
        raise InvalidParamError(behaviour, SELECTION_BEHAVIOUR)
    self.setSelectionBehavior(SELECTION_BEHAVIOUR[behaviour])

set_selection_mode(mode: SelectionModeStr | None)

Set selection mode for given item view.

Parameters:

Name Type Description Default
mode SelectionModeStr | None

selection mode to use

required

Raises:

Type Description
InvalidParamError

mode does not exist

Source code in prettyqt\widgets\abstractitemview.py
def set_selection_mode(self, mode: SelectionModeStr | None):
    """Set selection mode for given item view.

    Args:
        mode: selection mode to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode is None:
        mode = "none"
    if mode not in SELECTION_MODE:
        raise InvalidParamError(mode, SELECTION_MODE)
    self.setSelectionMode(SELECTION_MODE[mode])

set_table_color(color: str)

Source code in prettyqt\widgets\abstractitemview.py
def set_table_color(self, color: str):
    with self.edit_stylesheet() as ss:
        ss.QHeaderView.section.backgroundColor.setValue(color)

set_vertical_scroll_mode(mode: ScrollModeStr)

Set the vertical scroll mode.

Parameters:

Name Type Description Default
mode ScrollModeStr

mode to set

required

Raises:

Type Description
InvalidParamError

invalid scroll mode

Source code in prettyqt\widgets\abstractitemview.py
def set_vertical_scroll_mode(self, mode: ScrollModeStr):
    """Set the vertical scroll mode.

    Args:
        mode: mode to set

    Raises:
        InvalidParamError: invalid scroll mode
    """
    if mode not in SCROLL_MODE:
        raise InvalidParamError(mode, SCROLL_MODE)
    self.setVerticalScrollMode(SCROLL_MODE[mode])

setup_dragdrop_move()

Source code in prettyqt\widgets\abstractitemview.py
def setup_dragdrop_move(self):
    self.setDragEnabled(True)
    self.setAcceptDrops(True)
    self.setDragDropMode(self.DragDropMode.DragDrop)
    self.setDefaultDropAction(constants.MOVE_ACTION)
    self.setDropIndicatorShown(True)

toggle_select_all()

Select all items from list (deselect when all selected).

Source code in prettyqt\widgets\abstractitemview.py
def toggle_select_all(self):
    """Select all items from list (deselect when all selected)."""
    if self.selectionModel() is None:
        return
    if self.selectionModel().hasSelection():
        self.clearSelection()
    else:
        self.selectAll()

AbstractScrollArea

Bases: AbstractScrollAreaMixin, QtWidgets.QAbstractScrollArea

Source code in prettyqt\widgets\abstractscrollarea.py
class AbstractScrollArea(AbstractScrollAreaMixin, QtWidgets.QAbstractScrollArea):
    pass

AbstractScrollAreaMixin

Bases: widgets.FrameMixin

Source code in prettyqt\widgets\abstractscrollarea.py
class AbstractScrollAreaMixin(widgets.FrameMixin):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.setHorizontalScrollBar(widgets.ScrollBar(parent=self))
        self.setVerticalScrollBar(widgets.ScrollBar(parent=self))

    @property
    def h_scrollbar(self):
        return self.horizontalScrollBar()

    @h_scrollbar.setter
    def h_scrollbar(self, scrollbar):
        self.setHorizontalScrollBar(scrollbar)

    @property
    def v_scrollbar(self):
        return self.verticalScrollBar()

    @v_scrollbar.setter
    def v_scrollbar(self, scrollbar):
        self.setVerticalScrollBar(scrollbar)

    def set_size_adjust_policy(self, policy: SizePolicyStr):
        """Set size adjust policy.

        Args:
            policy: size adjust policy to use

        Raises:
            InvalidParamError: invalid size adjust policy
        """
        if policy not in SIZE_POLICY:
            raise InvalidParamError(policy, SIZE_POLICY)
        self.setSizeAdjustPolicy(SIZE_POLICY[policy])

    def get_size_adjust_policy(self) -> SizePolicyStr:
        """Return size adjust policy.

        Returns:
            size adjust policy
        """
        return SIZE_POLICY.inverse[self.sizeAdjustPolicy()]

    def set_scrollbar_policy(self, mode: constants.ScrollBarPolicyStr):
        """Set the policy for both scrollbars.

        Args:
            mode: visibilty to set

        Raises:
            InvalidParamError: invalid scrollbar policy
        """
        if mode not in constants.SCROLLBAR_POLICY:
            raise InvalidParamError(mode, constants.SCROLLBAR_POLICY)
        self.setHorizontalScrollBarPolicy(constants.SCROLLBAR_POLICY[mode])
        self.setVerticalScrollBarPolicy(constants.SCROLLBAR_POLICY[mode])

    def set_horizontal_scrollbar_policy(self, mode: constants.ScrollBarPolicyStr):
        """Set the horizontal scrollbar visibility.

        Args:
            mode: visibilty to set

        Raises:
            InvalidParamError: invalid scrollbar policy
        """
        if mode not in constants.SCROLLBAR_POLICY:
            raise InvalidParamError(mode, constants.SCROLLBAR_POLICY)
        self.setHorizontalScrollBarPolicy(constants.SCROLLBAR_POLICY[mode])

    def get_horizontal_scrollbar_policy(self):
        return constants.SCROLLBAR_POLICY.inverse[self.horizontalScrollBarPolicy()]

    def set_vertical_scrollbar_policy(self, mode: constants.ScrollBarPolicyStr):
        """Set the vertical scrollbar visibility.

        Args:
            mode: visibilty to set

        Raises:
            InvalidParamError: invalid scrollbar policy
        """
        if mode not in constants.SCROLLBAR_POLICY:
            raise InvalidParamError(mode, constants.SCROLLBAR_POLICY)
        self.setVerticalScrollBarPolicy(constants.SCROLLBAR_POLICY[mode])

    def get_vertical_scrollbar_policy(self):
        return constants.SCROLLBAR_POLICY.inverse[self.verticalScrollBarPolicy()]

    def set_scrollbar_width(self, width: int):
        """Set the width for both scrollbars.

        Args:
            width: width in pixels
        """
        self.set_horizontal_scrollbar_width(width)
        self.set_vertical_scrollbar_width(width)

    def set_horizontal_scrollbar_width(self, width: int):
        """Set the horizontal scrollbar width.

        Args:
            width: width in pixels
        """
        with self.h_scrollbar.edit_stylesheet() as ss:
            ss.QScrollBar.horizontal.height.setValue(f"{width}px")

    def set_vertical_scrollbar_width(self, width: int):
        """Set the vertical scrollbar width.

        Args:
            width: width in pixels
        """
        with self.v_scrollbar.edit_stylesheet() as ss:
            ss.QScrollBar.horizontal.height.setValue(f"{width}px")

    def scroll_to_top(self):
        """Scroll to the top of the scroll area."""
        self.verticalScrollBar().scroll_to_min()

    def scroll_to_bottom(self):
        """Scroll to the bottom of the scroll area."""
        self.verticalScrollBar().scroll_to_max()

h_scrollbar writable property

v_scrollbar writable property

__init__(*args, **kwargs)

Source code in prettyqt\widgets\abstractscrollarea.py
def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.setHorizontalScrollBar(widgets.ScrollBar(parent=self))
    self.setVerticalScrollBar(widgets.ScrollBar(parent=self))

get_horizontal_scrollbar_policy()

Source code in prettyqt\widgets\abstractscrollarea.py
def get_horizontal_scrollbar_policy(self):
    return constants.SCROLLBAR_POLICY.inverse[self.horizontalScrollBarPolicy()]

get_size_adjust_policy() -> SizePolicyStr

Return size adjust policy.

Returns:

Type Description
SizePolicyStr

size adjust policy

Source code in prettyqt\widgets\abstractscrollarea.py
def get_size_adjust_policy(self) -> SizePolicyStr:
    """Return size adjust policy.

    Returns:
        size adjust policy
    """
    return SIZE_POLICY.inverse[self.sizeAdjustPolicy()]

get_vertical_scrollbar_policy()

Source code in prettyqt\widgets\abstractscrollarea.py
def get_vertical_scrollbar_policy(self):
    return constants.SCROLLBAR_POLICY.inverse[self.verticalScrollBarPolicy()]

scroll_to_bottom()

Scroll to the bottom of the scroll area.

Source code in prettyqt\widgets\abstractscrollarea.py
def scroll_to_bottom(self):
    """Scroll to the bottom of the scroll area."""
    self.verticalScrollBar().scroll_to_max()

scroll_to_top()

Scroll to the top of the scroll area.

Source code in prettyqt\widgets\abstractscrollarea.py
def scroll_to_top(self):
    """Scroll to the top of the scroll area."""
    self.verticalScrollBar().scroll_to_min()

set_horizontal_scrollbar_policy(mode: constants.ScrollBarPolicyStr)

Set the horizontal scrollbar visibility.

Parameters:

Name Type Description Default
mode constants.ScrollBarPolicyStr

visibilty to set

required

Raises:

Type Description
InvalidParamError

invalid scrollbar policy

Source code in prettyqt\widgets\abstractscrollarea.py
def set_horizontal_scrollbar_policy(self, mode: constants.ScrollBarPolicyStr):
    """Set the horizontal scrollbar visibility.

    Args:
        mode: visibilty to set

    Raises:
        InvalidParamError: invalid scrollbar policy
    """
    if mode not in constants.SCROLLBAR_POLICY:
        raise InvalidParamError(mode, constants.SCROLLBAR_POLICY)
    self.setHorizontalScrollBarPolicy(constants.SCROLLBAR_POLICY[mode])

set_horizontal_scrollbar_width(width: int)

Set the horizontal scrollbar width.

Parameters:

Name Type Description Default
width int

width in pixels

required
Source code in prettyqt\widgets\abstractscrollarea.py
def set_horizontal_scrollbar_width(self, width: int):
    """Set the horizontal scrollbar width.

    Args:
        width: width in pixels
    """
    with self.h_scrollbar.edit_stylesheet() as ss:
        ss.QScrollBar.horizontal.height.setValue(f"{width}px")

set_scrollbar_policy(mode: constants.ScrollBarPolicyStr)

Set the policy for both scrollbars.

Parameters:

Name Type Description Default
mode constants.ScrollBarPolicyStr

visibilty to set

required

Raises:

Type Description
InvalidParamError

invalid scrollbar policy

Source code in prettyqt\widgets\abstractscrollarea.py
def set_scrollbar_policy(self, mode: constants.ScrollBarPolicyStr):
    """Set the policy for both scrollbars.

    Args:
        mode: visibilty to set

    Raises:
        InvalidParamError: invalid scrollbar policy
    """
    if mode not in constants.SCROLLBAR_POLICY:
        raise InvalidParamError(mode, constants.SCROLLBAR_POLICY)
    self.setHorizontalScrollBarPolicy(constants.SCROLLBAR_POLICY[mode])
    self.setVerticalScrollBarPolicy(constants.SCROLLBAR_POLICY[mode])

set_scrollbar_width(width: int)

Set the width for both scrollbars.

Parameters:

Name Type Description Default
width int

width in pixels

required
Source code in prettyqt\widgets\abstractscrollarea.py
def set_scrollbar_width(self, width: int):
    """Set the width for both scrollbars.

    Args:
        width: width in pixels
    """
    self.set_horizontal_scrollbar_width(width)
    self.set_vertical_scrollbar_width(width)

set_size_adjust_policy(policy: SizePolicyStr)

Set size adjust policy.

Parameters:

Name Type Description Default
policy SizePolicyStr

size adjust policy to use

required

Raises:

Type Description
InvalidParamError

invalid size adjust policy

Source code in prettyqt\widgets\abstractscrollarea.py
def set_size_adjust_policy(self, policy: SizePolicyStr):
    """Set size adjust policy.

    Args:
        policy: size adjust policy to use

    Raises:
        InvalidParamError: invalid size adjust policy
    """
    if policy not in SIZE_POLICY:
        raise InvalidParamError(policy, SIZE_POLICY)
    self.setSizeAdjustPolicy(SIZE_POLICY[policy])

set_vertical_scrollbar_policy(mode: constants.ScrollBarPolicyStr)

Set the vertical scrollbar visibility.

Parameters:

Name Type Description Default
mode constants.ScrollBarPolicyStr

visibilty to set

required

Raises:

Type Description
InvalidParamError

invalid scrollbar policy

Source code in prettyqt\widgets\abstractscrollarea.py
def set_vertical_scrollbar_policy(self, mode: constants.ScrollBarPolicyStr):
    """Set the vertical scrollbar visibility.

    Args:
        mode: visibilty to set

    Raises:
        InvalidParamError: invalid scrollbar policy
    """
    if mode not in constants.SCROLLBAR_POLICY:
        raise InvalidParamError(mode, constants.SCROLLBAR_POLICY)
    self.setVerticalScrollBarPolicy(constants.SCROLLBAR_POLICY[mode])

set_vertical_scrollbar_width(width: int)

Set the vertical scrollbar width.

Parameters:

Name Type Description Default
width int

width in pixels

required
Source code in prettyqt\widgets\abstractscrollarea.py
def set_vertical_scrollbar_width(self, width: int):
    """Set the vertical scrollbar width.

    Args:
        width: width in pixels
    """
    with self.v_scrollbar.edit_stylesheet() as ss:
        ss.QScrollBar.horizontal.height.setValue(f"{width}px")

AbstractSlider

Bases: AbstractSliderMixin, QtWidgets.QAbstractSlider

Source code in prettyqt\widgets\abstractslider.py
class AbstractSlider(AbstractSliderMixin, QtWidgets.QAbstractSlider):
    pass

AbstractSliderMixin

Bases: widgets.WidgetMixin

Source code in prettyqt\widgets\abstractslider.py
class AbstractSliderMixin(widgets.WidgetMixin):
    value_changed = core.Signal(int)

    def on_value_change(self):
        self.value_changed.emit(self.value())

    def is_horizontal(self) -> bool:
        """Check if silder is horizontal.

        Returns:
            True if horizontal, else False
        """
        return self.orientation() == constants.HORIZONTAL

    def is_vertical(self) -> bool:
        """Check if silder is vertical.

        Returns:
            True if vertical, else False
        """
        return self.orientation() == constants.VERTICAL

    def set_horizontal(self):
        """Set slider orientation to horizontal."""
        self.setOrientation(constants.HORIZONTAL)

    def set_vertical(self):
        """Set slider orientation to vertical."""
        self.setOrientation(constants.VERTICAL)

    def set_orientation(self, orientation: constants.OrientationStr):
        """Set the orientation of the slider.

        Args:
            orientation: orientation for the slider

        Raises:
            InvalidParamError: orientation does not exist
        """
        if orientation not in constants.ORIENTATION:
            raise InvalidParamError(orientation, constants.ORIENTATION)
        self.setOrientation(constants.ORIENTATION[orientation])

    def get_orientation(self) -> constants.OrientationStr:
        """Return current orientation.

        Returns:
            orientation
        """
        return constants.ORIENTATION.inverse[self.orientation()]

    def scroll_to_min(self):
        """Scroll to the minimum value of the slider."""
        self.setValue(self.minimum())

    def scroll_to_max(self):
        """Scroll to the maximum value of the slider."""
        self.setValue(self.maximum())

    def set_range(self, min_val: int, max_val: int):
        self.setRange(min_val, max_val)

    def set_step_size(self, step_size: int):
        self.setSingleStep(step_size)

    def set_repeat_action(
        self, action: SliderActionStr, threshold: int = 500, repeat_time: int = 50
    ):
        """Set the repeat action.

        Args:
            action: repeat action
            threshold: initial delay in ms
            repeat_time: repeat time in ms

        Raises:
            InvalidParamError: invalid repeat action
        """
        if action not in SLIDER_ACTION:
            raise InvalidParamError(action, SLIDER_ACTION)
        self.setRepeatAction(SLIDER_ACTION[action], threshold, repeat_time)

    def get_repeat_action(self) -> SliderActionStr:
        """Get current repeat action.

        Returns:
            current repeat action
        """
        return SLIDER_ACTION.inverse[self.repeatAction()]

    def trigger_action(self, action: SliderActionStr):
        """Trigger slider action."""
        if action not in SLIDER_ACTION:
            raise InvalidParamError(action, SLIDER_ACTION)
        self.triggerAction(SLIDER_ACTION[action])

    def get_value(self):
        return self.value()

    def set_value(self, value: int):
        self.setValue(value)

    def on_scrollbar_range_changed(self, minval, maxval):
        if self.value() >= self.maximum() - 1:
            self.setValue(maxval)

    def set_auto_scroll_to_end(self, scroll: bool = True):
        """Set to always scroll to the end when range changes."""
        if scroll:
            self.rangeChanged.connect(self.on_scrollbar_range_changed)
        else:
            self.rangeChanged.disconnect(self.on_scrollbar_range_changed)

value_changed = core.Signal(int) class-attribute

get_orientation() -> constants.OrientationStr

Return current orientation.

Returns:

Type Description
constants.OrientationStr

orientation

Source code in prettyqt\widgets\abstractslider.py
def get_orientation(self) -> constants.OrientationStr:
    """Return current orientation.

    Returns:
        orientation
    """
    return constants.ORIENTATION.inverse[self.orientation()]

get_repeat_action() -> SliderActionStr

Get current repeat action.

Returns:

Type Description
SliderActionStr

current repeat action

Source code in prettyqt\widgets\abstractslider.py
def get_repeat_action(self) -> SliderActionStr:
    """Get current repeat action.

    Returns:
        current repeat action
    """
    return SLIDER_ACTION.inverse[self.repeatAction()]

get_value()

Source code in prettyqt\widgets\abstractslider.py
def get_value(self):
    return self.value()

is_horizontal() -> bool

Check if silder is horizontal.

Returns:

Type Description
bool

True if horizontal, else False

Source code in prettyqt\widgets\abstractslider.py
def is_horizontal(self) -> bool:
    """Check if silder is horizontal.

    Returns:
        True if horizontal, else False
    """
    return self.orientation() == constants.HORIZONTAL

is_vertical() -> bool

Check if silder is vertical.

Returns:

Type Description
bool

True if vertical, else False

Source code in prettyqt\widgets\abstractslider.py
def is_vertical(self) -> bool:
    """Check if silder is vertical.

    Returns:
        True if vertical, else False
    """
    return self.orientation() == constants.VERTICAL

on_scrollbar_range_changed(minval, maxval)

Source code in prettyqt\widgets\abstractslider.py
def on_scrollbar_range_changed(self, minval, maxval):
    if self.value() >= self.maximum() - 1:
        self.setValue(maxval)

on_value_change()

Source code in prettyqt\widgets\abstractslider.py
def on_value_change(self):
    self.value_changed.emit(self.value())

scroll_to_max()

Scroll to the maximum value of the slider.

Source code in prettyqt\widgets\abstractslider.py
def scroll_to_max(self):
    """Scroll to the maximum value of the slider."""
    self.setValue(self.maximum())

scroll_to_min()

Scroll to the minimum value of the slider.

Source code in prettyqt\widgets\abstractslider.py
def scroll_to_min(self):
    """Scroll to the minimum value of the slider."""
    self.setValue(self.minimum())

set_auto_scroll_to_end(scroll: bool = True)

Set to always scroll to the end when range changes.

Source code in prettyqt\widgets\abstractslider.py
def set_auto_scroll_to_end(self, scroll: bool = True):
    """Set to always scroll to the end when range changes."""
    if scroll:
        self.rangeChanged.connect(self.on_scrollbar_range_changed)
    else:
        self.rangeChanged.disconnect(self.on_scrollbar_range_changed)

set_horizontal()

Set slider orientation to horizontal.

Source code in prettyqt\widgets\abstractslider.py
def set_horizontal(self):
    """Set slider orientation to horizontal."""
    self.setOrientation(constants.HORIZONTAL)

set_orientation(orientation: constants.OrientationStr)

Set the orientation of the slider.

Parameters:

Name Type Description Default
orientation constants.OrientationStr

orientation for the slider

required

Raises:

Type Description
InvalidParamError

orientation does not exist

Source code in prettyqt\widgets\abstractslider.py
def set_orientation(self, orientation: constants.OrientationStr):
    """Set the orientation of the slider.

    Args:
        orientation: orientation for the slider

    Raises:
        InvalidParamError: orientation does not exist
    """
    if orientation not in constants.ORIENTATION:
        raise InvalidParamError(orientation, constants.ORIENTATION)
    self.setOrientation(constants.ORIENTATION[orientation])

set_range(min_val: int, max_val: int)

Source code in prettyqt\widgets\abstractslider.py
def set_range(self, min_val: int, max_val: int):
    self.setRange(min_val, max_val)

set_repeat_action(action: SliderActionStr, threshold: int = 500, repeat_time: int = 50)

Set the repeat action.

Parameters:

Name Type Description Default
action SliderActionStr

repeat action

required
threshold int

initial delay in ms

500
repeat_time int

repeat time in ms

50

Raises:

Type Description
InvalidParamError

invalid repeat action

Source code in prettyqt\widgets\abstractslider.py
def set_repeat_action(
    self, action: SliderActionStr, threshold: int = 500, repeat_time: int = 50
):
    """Set the repeat action.

    Args:
        action: repeat action
        threshold: initial delay in ms
        repeat_time: repeat time in ms

    Raises:
        InvalidParamError: invalid repeat action
    """
    if action not in SLIDER_ACTION:
        raise InvalidParamError(action, SLIDER_ACTION)
    self.setRepeatAction(SLIDER_ACTION[action], threshold, repeat_time)

set_step_size(step_size: int)

Source code in prettyqt\widgets\abstractslider.py
def set_step_size(self, step_size: int):
    self.setSingleStep(step_size)

set_value(value: int)

Source code in prettyqt\widgets\abstractslider.py
def set_value(self, value: int):
    self.setValue(value)

set_vertical()

Set slider orientation to vertical.

Source code in prettyqt\widgets\abstractslider.py
def set_vertical(self):
    """Set slider orientation to vertical."""
    self.setOrientation(constants.VERTICAL)

trigger_action(action: SliderActionStr)

Trigger slider action.

Source code in prettyqt\widgets\abstractslider.py
def trigger_action(self, action: SliderActionStr):
    """Trigger slider action."""
    if action not in SLIDER_ACTION:
        raise InvalidParamError(action, SLIDER_ACTION)
    self.triggerAction(SLIDER_ACTION[action])

AbstractSpinBox

Bases: AbstractSpinBoxMixin, QtWidgets.QAbstractSpinBox

Source code in prettyqt\widgets\abstractspinbox.py
class AbstractSpinBox(AbstractSpinBoxMixin, QtWidgets.QAbstractSpinBox):
    pass

AbstractSpinBoxMixin

Bases: widgets.WidgetMixin

Source code in prettyqt\widgets\abstractspinbox.py
class AbstractSpinBoxMixin(widgets.WidgetMixin):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.setLineEdit(widgets.LineEdit())
        self.setGroupSeparatorShown(True)

    def is_valid(self) -> bool:
        return self.hasAcceptableInput()

    def set_validator(self, validator: gui.Validator):
        self.lineEdit().setValidator(validator)

    def get_button_symbols(self) -> SymbolStr:
        """Return button symbol type.

        Returns:
            button symbol type
        """
        return SYMBOLS.inverse[self.buttonSymbols()]

    def set_button_symbols(self, mode: SymbolStr):
        """Set button symbol type.

        Args:
            mode: button symbol type to use

        Raises:
            InvalidParamError: invalid button symbol type
        """
        if mode not in SYMBOLS:
            raise InvalidParamError(mode, SYMBOLS)
        self.setButtonSymbols(SYMBOLS[mode])

    def set_correction_mode(self, mode: CorrectionModeStr):
        """Set correction mode.

        Args:
            mode: correction mode to use

        Raises:
            InvalidParamError: invalid correction mode
        """
        if mode not in CORRECTION_MODES:
            raise InvalidParamError(mode, CORRECTION_MODES)
        self.setCorrectionMode(CORRECTION_MODES[mode])

    def get_correction_mode(self) -> CorrectionModeStr:
        """Return correction mode.

        Returns:
            correction mode
        """
        return CORRECTION_MODES.inverse[self.correctionMode()]

    def set_step_type(self, mode: StepTypeStr):
        """Set step type.

        Args:
            mode: step type to use

        Raises:
            InvalidParamError: invalid step type
        """
        if mode not in STEP_TYPES:
            raise InvalidParamError(mode, STEP_TYPES)
        self.setStepType(STEP_TYPES[mode])

    def get_step_type(self) -> StepTypeStr:
        """Return step type.

        Returns:
            step type
        """
        return STEP_TYPES.inverse[self.stepType()]

    def set_special_value(self, value: str):
        self.setSpecialValueText(value)

    def get_value(self) -> int:
        return self.value()

    def set_value(self, value: int | float):
        self.setValue(value)

__init__(*args, **kwargs)

Source code in prettyqt\widgets\abstractspinbox.py
def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.setLineEdit(widgets.LineEdit())
    self.setGroupSeparatorShown(True)

get_button_symbols() -> SymbolStr

Return button symbol type.

Returns:

Type Description
SymbolStr

button symbol type

Source code in prettyqt\widgets\abstractspinbox.py
def get_button_symbols(self) -> SymbolStr:
    """Return button symbol type.

    Returns:
        button symbol type
    """
    return SYMBOLS.inverse[self.buttonSymbols()]

get_correction_mode() -> CorrectionModeStr

Return correction mode.

Returns:

Type Description
CorrectionModeStr

correction mode

Source code in prettyqt\widgets\abstractspinbox.py
def get_correction_mode(self) -> CorrectionModeStr:
    """Return correction mode.

    Returns:
        correction mode
    """
    return CORRECTION_MODES.inverse[self.correctionMode()]

get_step_type() -> StepTypeStr

Return step type.

Returns:

Type Description
StepTypeStr

step type

Source code in prettyqt\widgets\abstractspinbox.py
def get_step_type(self) -> StepTypeStr:
    """Return step type.

    Returns:
        step type
    """
    return STEP_TYPES.inverse[self.stepType()]

get_value() -> int

Source code in prettyqt\widgets\abstractspinbox.py
def get_value(self) -> int:
    return self.value()

is_valid() -> bool

Source code in prettyqt\widgets\abstractspinbox.py
def is_valid(self) -> bool:
    return self.hasAcceptableInput()

set_button_symbols(mode: SymbolStr)

Set button symbol type.

Parameters:

Name Type Description Default
mode SymbolStr

button symbol type to use

required

Raises:

Type Description
InvalidParamError

invalid button symbol type

Source code in prettyqt\widgets\abstractspinbox.py
def set_button_symbols(self, mode: SymbolStr):
    """Set button symbol type.

    Args:
        mode: button symbol type to use

    Raises:
        InvalidParamError: invalid button symbol type
    """
    if mode not in SYMBOLS:
        raise InvalidParamError(mode, SYMBOLS)
    self.setButtonSymbols(SYMBOLS[mode])

set_correction_mode(mode: CorrectionModeStr)

Set correction mode.

Parameters:

Name Type Description Default
mode CorrectionModeStr

correction mode to use

required

Raises:

Type Description
InvalidParamError

invalid correction mode

Source code in prettyqt\widgets\abstractspinbox.py
def set_correction_mode(self, mode: CorrectionModeStr):
    """Set correction mode.

    Args:
        mode: correction mode to use

    Raises:
        InvalidParamError: invalid correction mode
    """
    if mode not in CORRECTION_MODES:
        raise InvalidParamError(mode, CORRECTION_MODES)
    self.setCorrectionMode(CORRECTION_MODES[mode])

set_special_value(value: str)

Source code in prettyqt\widgets\abstractspinbox.py
def set_special_value(self, value: str):
    self.setSpecialValueText(value)

set_step_type(mode: StepTypeStr)

Set step type.

Parameters:

Name Type Description Default
mode StepTypeStr

step type to use

required

Raises:

Type Description
InvalidParamError

invalid step type

Source code in prettyqt\widgets\abstractspinbox.py
def set_step_type(self, mode: StepTypeStr):
    """Set step type.

    Args:
        mode: step type to use

    Raises:
        InvalidParamError: invalid step type
    """
    if mode not in STEP_TYPES:
        raise InvalidParamError(mode, STEP_TYPES)
    self.setStepType(STEP_TYPES[mode])

set_validator(validator: gui.Validator)

Source code in prettyqt\widgets\abstractspinbox.py
def set_validator(self, validator: gui.Validator):
    self.lineEdit().setValidator(validator)

set_value(value: int | float)

Source code in prettyqt\widgets\abstractspinbox.py
def set_value(self, value: int | float):
    self.setValue(value)

Action

Bases: ActionMixin, prettyprinter.PrettyPrinter, QtWidgets.QAction

Source code in prettyqt\widgets\action.py
class Action(ActionMixin, prettyprinter.PrettyPrinter, QtWidgets.QAction):
    pass

ActionGroup

Bases: core.ObjectMixin, QtWidgets.QActionGroup

Source code in prettyqt\widgets\actiongroup.py
class ActionGroup(core.ObjectMixin, QtWidgets.QActionGroup):
    def __init__(self, parent: QtCore.QObject | None = None):
        super().__init__(parent)  # type: ignore

    def __len__(self) -> int:
        return len(self.actions())

    def __getitem__(self, item: int) -> QtWidgets.QAction:
        return self.actions()[item]

    def set_exclusion_policy(self, policy: ExclusionPolicyStr | None):
        """Set exclusion policy to use.

        Args:
            policy: exclusion policy to use

        Raises:
            InvalidParamError: exclusion policy does not exist
        """
        if policy is None:
            policy = "none"
        if policy not in POLICIES:
            raise InvalidParamError(policy, POLICIES)
        self.setExclusionPolicy(POLICIES[policy])

    def get_exclusion_policy(self) -> ExclusionPolicyStr:
        """Return current exclusion policy.

        Returns:
            exclusion policy
        """
        return POLICIES.inverse[self.exclusionPolicy()]

__getitem__(item: int) -> QtWidgets.QAction

Source code in prettyqt\widgets\actiongroup.py
def __getitem__(self, item: int) -> QtWidgets.QAction:
    return self.actions()[item]

__init__(parent: QtCore.QObject | None = None)

Source code in prettyqt\widgets\actiongroup.py
def __init__(self, parent: QtCore.QObject | None = None):
    super().__init__(parent)  # type: ignore

__len__() -> int

Source code in prettyqt\widgets\actiongroup.py
def __len__(self) -> int:
    return len(self.actions())

get_exclusion_policy() -> ExclusionPolicyStr

Return current exclusion policy.

Returns:

Type Description
ExclusionPolicyStr

exclusion policy

Source code in prettyqt\widgets\actiongroup.py
def get_exclusion_policy(self) -> ExclusionPolicyStr:
    """Return current exclusion policy.

    Returns:
        exclusion policy
    """
    return POLICIES.inverse[self.exclusionPolicy()]

set_exclusion_policy(policy: ExclusionPolicyStr | None)

Set exclusion policy to use.

Parameters:

Name Type Description Default
policy ExclusionPolicyStr | None

exclusion policy to use

required

Raises:

Type Description
InvalidParamError

exclusion policy does not exist

Source code in prettyqt\widgets\actiongroup.py
def set_exclusion_policy(self, policy: ExclusionPolicyStr | None):
    """Set exclusion policy to use.

    Args:
        policy: exclusion policy to use

    Raises:
        InvalidParamError: exclusion policy does not exist
    """
    if policy is None:
        policy = "none"
    if policy not in POLICIES:
        raise InvalidParamError(policy, POLICIES)
    self.setExclusionPolicy(POLICIES[policy])

ActionMixin

Bases: core.ObjectMixin

Source code in prettyqt\widgets\action.py
class ActionMixin(core.ObjectMixin):
    def __init__(
        self,
        parent: QtCore.QObject | None = None,
        text: str = "",
        icon: datatypes.IconType = None,
        shortcut: str | None = None,
        tooltip: str = "",
        checkable: bool = False,
        checked: bool = False,
        statustip: str = "",
        enabled: bool = True,
        callback: Callable | None = None,
    ):
        super().__init__(parent)
        self._menu = None
        self.set_text(text)
        self.set_icon(icon)
        self.set_shortcut(shortcut)
        self.set_tooltip(tooltip)
        self.set_checkable(checkable)
        self.set_checked(checked)
        self.set_statustip(statustip)
        self.set_enabled(enabled)
        if callback is not None:
            self.triggered.connect(callback)

    def __repr__(self) -> str:
        return get_repr(self, self.text())

    def set_text(self, text: str):
        self.setText(text)

    def set_enabled(self, enabled: bool = True):
        self.setEnabled(enabled)

    def set_disabled(self):
        self.setEnabled(False)

    def set_tooltip(
        self,
        tooltip: str | datatypes.PathType,
        size: datatypes.SizeType | None = None,
    ):
        if isinstance(tooltip, os.PathLike):
            path = os.fspath(tooltip)
            if size is None:
                tooltip = f"<img src={path!r}>"
            else:
                if isinstance(size, QtCore.QSize):
                    size = (size.width(), size.height())
                tooltip = f'<img src={path!r} width="{size[0]}" height="{size[1]}">'
        self.setToolTip(tooltip)

    def set_statustip(self, text: str):
        self.setStatusTip(text)

    def set_checked(self, value: bool):
        self.setChecked(value)

    def set_checkable(self, value: bool):
        self.setCheckable(value)

    def set_icon(self, icon: datatypes.IconType):
        """Set the icon for the action.

        Args:
            icon: icon to use
        """
        icon = iconprovider.get_icon(icon)
        self.setIcon(icon)

    def get_icon(self) -> gui.Icon | None:
        icon = self.icon()
        return None if icon.isNull() else gui.Icon(icon)

    def set_shortcut(self, shortcut: None | QtGui.QKeySequence | str):
        if shortcut is None:
            shortcut = ""
        if isinstance(shortcut, str):
            shortcut = gui.KeySequence(
                shortcut, gui.KeySequence.SequenceFormat.PortableText
            )
        self.setShortcut(shortcut)

    def get_shortcut(self) -> gui.KeySequence | None:
        shortcut = self.shortcut()
        return (
            gui.KeySequence(
                shortcut.toString(), gui.KeySequence.SequenceFormat.PortableText
            )
            if shortcut
            else None
        )

    def get_font(self) -> gui.Font:
        return gui.Font(self.font())

    def set_menu(self, menu):
        try:
            self.setMenu(menu)
        except AttributeError:
            self.triggered.connect(menu.exec)
            self._menu = menu

    def menu(self):
        return self._menu

    def set_priority(self, priority: PriorityStr):
        """Set priority of the action.

        Args:
            priority: priority for the action

        Raises:
            InvalidParamError: priority does not exist
        """
        if priority not in PRIORITIES:
            raise InvalidParamError(priority, PRIORITIES)
        self.setPriority(PRIORITIES[priority])

    def get_priority(self) -> PriorityStr:
        """Return current priority.

        Returns:
            priority
        """
        return PRIORITIES.inverse[self.priority()]

    def set_shortcut_context(self, context: constants.ContextStr):
        """Set shortcut context.

        Args:
            context: shortcut context

        Raises:
            InvalidParamError: shortcut context does not exist
        """
        if context not in constants.CONTEXT:
            raise InvalidParamError(context, constants.CONTEXT)
        self.setShortcutContext(constants.CONTEXT[context])

    def get_shortcut_context(self) -> constants.ContextStr:
        """Return shortcut context.

        Returns:
            shortcut context
        """
        return constants.CONTEXT.inverse[self.shortcutContext()]

    def set_menu_role(self, role: RoleStr):
        """Set menu role.

        Args:
            role: menu role

        Raises:
            InvalidParamError: menu role does not exist
        """
        if role not in ROLES:
            raise InvalidParamError(role, ROLES)
        self.setMenuRole(ROLES[role])

    def get_menu_role(self) -> RoleStr:
        """Return menu role.

        Returns:
            menu role
        """
        return ROLES.inverse[self.menuRole()]

    def show_shortcut_in_contextmenu(self, state: bool = True):
        self.setShortcutVisibleInContextMenu(state)

__init__(parent: QtCore.QObject | None = None, text: str = '', icon: datatypes.IconType = None, shortcut: str | None = None, tooltip: str = '', checkable: bool = False, checked: bool = False, statustip: str = '', enabled: bool = True, callback: Callable | None = None)

Source code in prettyqt\widgets\action.py
def __init__(
    self,
    parent: QtCore.QObject | None = None,
    text: str = "",
    icon: datatypes.IconType = None,
    shortcut: str | None = None,
    tooltip: str = "",
    checkable: bool = False,
    checked: bool = False,
    statustip: str = "",
    enabled: bool = True,
    callback: Callable | None = None,
):
    super().__init__(parent)
    self._menu = None
    self.set_text(text)
    self.set_icon(icon)
    self.set_shortcut(shortcut)
    self.set_tooltip(tooltip)
    self.set_checkable(checkable)
    self.set_checked(checked)
    self.set_statustip(statustip)
    self.set_enabled(enabled)
    if callback is not None:
        self.triggered.connect(callback)

__repr__() -> str

Source code in prettyqt\widgets\action.py
def __repr__(self) -> str:
    return get_repr(self, self.text())

get_font() -> gui.Font

Source code in prettyqt\widgets\action.py
def get_font(self) -> gui.Font:
    return gui.Font(self.font())

get_icon() -> gui.Icon | None

Source code in prettyqt\widgets\action.py
def get_icon(self) -> gui.Icon | None:
    icon = self.icon()
    return None if icon.isNull() else gui.Icon(icon)

get_menu_role() -> RoleStr

Return menu role.

Returns:

Type Description
RoleStr

menu role

Source code in prettyqt\widgets\action.py
def get_menu_role(self) -> RoleStr:
    """Return menu role.

    Returns:
        menu role
    """
    return ROLES.inverse[self.menuRole()]

get_priority() -> PriorityStr

Return current priority.

Returns:

Type Description
PriorityStr

priority

Source code in prettyqt\widgets\action.py
def get_priority(self) -> PriorityStr:
    """Return current priority.

    Returns:
        priority
    """
    return PRIORITIES.inverse[self.priority()]

get_shortcut() -> gui.KeySequence | None

Source code in prettyqt\widgets\action.py
def get_shortcut(self) -> gui.KeySequence | None:
    shortcut = self.shortcut()
    return (
        gui.KeySequence(
            shortcut.toString(), gui.KeySequence.SequenceFormat.PortableText
        )
        if shortcut
        else None
    )

get_shortcut_context() -> constants.ContextStr

Return shortcut context.

Returns:

Type Description
constants.ContextStr

shortcut context

Source code in prettyqt\widgets\action.py
def get_shortcut_context(self) -> constants.ContextStr:
    """Return shortcut context.

    Returns:
        shortcut context
    """
    return constants.CONTEXT.inverse[self.shortcutContext()]

menu()

Source code in prettyqt\widgets\action.py
def menu(self):
    return self._menu

set_checkable(value: bool)

Source code in prettyqt\widgets\action.py
def set_checkable(self, value: bool):
    self.setCheckable(value)

set_checked(value: bool)

Source code in prettyqt\widgets\action.py
def set_checked(self, value: bool):
    self.setChecked(value)

set_disabled()

Source code in prettyqt\widgets\action.py
def set_disabled(self):
    self.setEnabled(False)

set_enabled(enabled: bool = True)

Source code in prettyqt\widgets\action.py
def set_enabled(self, enabled: bool = True):
    self.setEnabled(enabled)

set_icon(icon: datatypes.IconType)

Set the icon for the action.

Parameters:

Name Type Description Default
icon datatypes.IconType

icon to use

required
Source code in prettyqt\widgets\action.py
def set_icon(self, icon: datatypes.IconType):
    """Set the icon for the action.

    Args:
        icon: icon to use
    """
    icon = iconprovider.get_icon(icon)
    self.setIcon(icon)

set_menu(menu)

Source code in prettyqt\widgets\action.py
def set_menu(self, menu):
    try:
        self.setMenu(menu)
    except AttributeError:
        self.triggered.connect(menu.exec)
        self._menu = menu

set_menu_role(role: RoleStr)

Set menu role.

Parameters:

Name Type Description Default
role RoleStr

menu role

required

Raises:

Type Description
InvalidParamError

menu role does not exist

Source code in prettyqt\widgets\action.py
def set_menu_role(self, role: RoleStr):
    """Set menu role.

    Args:
        role: menu role

    Raises:
        InvalidParamError: menu role does not exist
    """
    if role not in ROLES:
        raise InvalidParamError(role, ROLES)
    self.setMenuRole(ROLES[role])

set_priority(priority: PriorityStr)

Set priority of the action.

Parameters:

Name Type Description Default
priority PriorityStr

priority for the action

required

Raises:

Type Description
InvalidParamError

priority does not exist

Source code in prettyqt\widgets\action.py
def set_priority(self, priority: PriorityStr):
    """Set priority of the action.

    Args:
        priority: priority for the action

    Raises:
        InvalidParamError: priority does not exist
    """
    if priority not in PRIORITIES:
        raise InvalidParamError(priority, PRIORITIES)
    self.setPriority(PRIORITIES[priority])

set_shortcut(shortcut: None | QtGui.QKeySequence | str)

Source code in prettyqt\widgets\action.py
def set_shortcut(self, shortcut: None | QtGui.QKeySequence | str):
    if shortcut is None:
        shortcut = ""
    if isinstance(shortcut, str):
        shortcut = gui.KeySequence(
            shortcut, gui.KeySequence.SequenceFormat.PortableText
        )
    self.setShortcut(shortcut)

set_shortcut_context(context: constants.ContextStr)

Set shortcut context.

Parameters:

Name Type Description Default
context constants.ContextStr

shortcut context

required

Raises:

Type Description
InvalidParamError

shortcut context does not exist

Source code in prettyqt\widgets\action.py
def set_shortcut_context(self, context: constants.ContextStr):
    """Set shortcut context.

    Args:
        context: shortcut context

    Raises:
        InvalidParamError: shortcut context does not exist
    """
    if context not in constants.CONTEXT:
        raise InvalidParamError(context, constants.CONTEXT)
    self.setShortcutContext(constants.CONTEXT[context])

set_statustip(text: str)

Source code in prettyqt\widgets\action.py
def set_statustip(self, text: str):
    self.setStatusTip(text)

set_text(text: str)

Source code in prettyqt\widgets\action.py
def set_text(self, text: str):
    self.setText(text)

set_tooltip(tooltip: str | datatypes.PathType, size: datatypes.SizeType | None = None)

Source code in prettyqt\widgets\action.py
def set_tooltip(
    self,
    tooltip: str | datatypes.PathType,
    size: datatypes.SizeType | None = None,
):
    if isinstance(tooltip, os.PathLike):
        path = os.fspath(tooltip)
        if size is None:
            tooltip = f"<img src={path!r}>"
        else:
            if isinstance(size, QtCore.QSize):
                size = (size.width(), size.height())
            tooltip = f'<img src={path!r} width="{size[0]}" height="{size[1]}">'
    self.setToolTip(tooltip)

show_shortcut_in_contextmenu(state: bool = True)

Source code in prettyqt\widgets\action.py
def show_shortcut_in_contextmenu(self, state: bool = True):
    self.setShortcutVisibleInContextMenu(state)

Application

Bases: ApplicationMixin, QtWidgets.QApplication

Source code in prettyqt\widgets\application.py
class Application(ApplicationMixin, QtWidgets.QApplication):
    pass

BoxLayout

Bases: BoxLayoutMixin, QtWidgets.QBoxLayout

Source code in prettyqt\widgets\boxlayout.py
class BoxLayout(BoxLayoutMixin, QtWidgets.QBoxLayout):
    pass

ButtonGroup

Bases: core.ObjectMixin, QtWidgets.QButtonGroup

Source code in prettyqt\widgets\buttongroup.py
class ButtonGroup(core.ObjectMixin, QtWidgets.QButtonGroup):
    def serialize_fields(self):
        return dict(exclusive=self.exclusive())

    def __getitem__(self, index: int) -> QtWidgets.QAbstractButton:
        return self.button(index)

__getitem__(index: int) -> QtWidgets.QAbstractButton

Source code in prettyqt\widgets\buttongroup.py
def __getitem__(self, index: int) -> QtWidgets.QAbstractButton:
    return self.button(index)

serialize_fields()

Source code in prettyqt\widgets\buttongroup.py
def serialize_fields(self):
    return dict(exclusive=self.exclusive())

CalendarWidget

Bases: widgets.WidgetMixin, QtWidgets.QCalendarWidget

Source code in prettyqt\widgets\calendarwidget.py
class CalendarWidget(widgets.WidgetMixin, QtWidgets.QCalendarWidget):
    def get_date(self) -> datetime.date:
        return self.selectedDate().toPython()  # type: ignore

    def get_value(self) -> datetime.date:
        return self.get_date()

    def set_value(self, value: datatypes.DateType):
        if isinstance(value, str):
            value = QtCore.QDate.fromString(value)
        self.setSelectedDate(value)  # type: ignore

    def set_range(
        self,
        lower: datatypes.DateType,
        upper: datatypes.DateType,
    ):
        if isinstance(lower, str):
            lower = QtCore.QDate.fromString(lower)
        if isinstance(upper, str):
            upper = QtCore.QDate.fromString(upper)
        self.setMinimumDate(lower)  # type: ignore
        self.setMaximumDate(upper)  # type: ignore

    def set_selection_mode(self, mode: SelectionModeStr | None):
        """Set selection mode for given calendar widget.

        Args:
            mode: selection mode to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode is None:
            mode = "none"
        if mode not in SELECTION_MODE:
            raise InvalidParamError(mode, SELECTION_MODE)
        self.setSelectionMode(SELECTION_MODE[mode])

    def get_selection_mode(self) -> SelectionModeStr:
        """Return current selection mode.

        Returns:
            selection mode
        """
        return SELECTION_MODE.inverse[self.selectionMode()]

get_date() -> datetime.date

Source code in prettyqt\widgets\calendarwidget.py
def get_date(self) -> datetime.date:
    return self.selectedDate().toPython()  # type: ignore

get_selection_mode() -> SelectionModeStr

Return current selection mode.

Returns:

Type Description
SelectionModeStr

selection mode

Source code in prettyqt\widgets\calendarwidget.py
def get_selection_mode(self) -> SelectionModeStr:
    """Return current selection mode.

    Returns:
        selection mode
    """
    return SELECTION_MODE.inverse[self.selectionMode()]

get_value() -> datetime.date

Source code in prettyqt\widgets\calendarwidget.py
def get_value(self) -> datetime.date:
    return self.get_date()

set_range(lower: datatypes.DateType, upper: datatypes.DateType)

Source code in prettyqt\widgets\calendarwidget.py
def set_range(
    self,
    lower: datatypes.DateType,
    upper: datatypes.DateType,
):
    if isinstance(lower, str):
        lower = QtCore.QDate.fromString(lower)
    if isinstance(upper, str):
        upper = QtCore.QDate.fromString(upper)
    self.setMinimumDate(lower)  # type: ignore
    self.setMaximumDate(upper)  # type: ignore

set_selection_mode(mode: SelectionModeStr | None)

Set selection mode for given calendar widget.

Parameters:

Name Type Description Default
mode SelectionModeStr | None

selection mode to use

required

Raises:

Type Description
InvalidParamError

mode does not exist

Source code in prettyqt\widgets\calendarwidget.py
def set_selection_mode(self, mode: SelectionModeStr | None):
    """Set selection mode for given calendar widget.

    Args:
        mode: selection mode to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode is None:
        mode = "none"
    if mode not in SELECTION_MODE:
        raise InvalidParamError(mode, SELECTION_MODE)
    self.setSelectionMode(SELECTION_MODE[mode])

set_value(value: datatypes.DateType)

Source code in prettyqt\widgets\calendarwidget.py
def set_value(self, value: datatypes.DateType):
    if isinstance(value, str):
        value = QtCore.QDate.fromString(value)
    self.setSelectedDate(value)  # type: ignore

CheckBox

Bases: widgets.AbstractButtonMixin, QtWidgets.QCheckBox

Source code in prettyqt\widgets\checkbox.py
class CheckBox(widgets.AbstractButtonMixin, QtWidgets.QCheckBox):
    value_changed = core.Signal(int)

    def __init__(
        self,
        label: str = "",
        parent: QtWidgets.QWidget | None = None,
        checked: bool = False,
    ):
        super().__init__(label, parent)
        self.stateChanged.connect(self.value_changed)
        self.setChecked(checked)

    def set_checkstate(self, state: constants.StateStr):
        """Set checkstate of the checkbox.

        Args:
            state: checkstate to use

        Raises:
            InvalidParamError: invalid checkstate
        """
        if state not in constants.STATE:
            raise InvalidParamError(state, constants.STATE)
        self.setCheckState(constants.STATE[state])

    def get_checkstate(self) -> constants.StateStr:
        """Return checkstate.

        Returns:
            checkstate
        """
        return constants.STATE.inverse[self.checkState()]

value_changed = core.Signal(int) class-attribute

__init__(label: str = '', parent: QtWidgets.QWidget | None = None, checked: bool = False)

Source code in prettyqt\widgets\checkbox.py
def __init__(
    self,
    label: str = "",
    parent: QtWidgets.QWidget | None = None,
    checked: bool = False,
):
    super().__init__(label, parent)
    self.stateChanged.connect(self.value_changed)
    self.setChecked(checked)

get_checkstate() -> constants.StateStr

Return checkstate.

Returns:

Type Description
constants.StateStr

checkstate

Source code in prettyqt\widgets\checkbox.py
def get_checkstate(self) -> constants.StateStr:
    """Return checkstate.

    Returns:
        checkstate
    """
    return constants.STATE.inverse[self.checkState()]

set_checkstate(state: constants.StateStr)

Set checkstate of the checkbox.

Parameters:

Name Type Description Default
state constants.StateStr

checkstate to use

required

Raises:

Type Description
InvalidParamError

invalid checkstate

Source code in prettyqt\widgets\checkbox.py
def set_checkstate(self, state: constants.StateStr):
    """Set checkstate of the checkbox.

    Args:
        state: checkstate to use

    Raises:
        InvalidParamError: invalid checkstate
    """
    if state not in constants.STATE:
        raise InvalidParamError(state, constants.STATE)
    self.setCheckState(constants.STATE[state])

ColorDialog

Bases: widgets.DialogMixin, QtWidgets.QColorDialog

Source code in prettyqt\widgets\colordialog.py
class ColorDialog(widgets.DialogMixin, QtWidgets.QColorDialog):
    @classmethod
    def get_color(
        cls,
        preset: datatypes.ColorType = None,
        allow_alpha: bool = False,
        parent: QtWidgets.QWidget | None = None,
    ) -> gui.Color:
        preset = colors.get_color(preset)
        kwargs = (
            dict(options=cls.ColorDialogOption.ShowAlphaChannel) if allow_alpha else {}
        )
        color = cls.getColor(preset, parent, **kwargs)  # type: ignore
        return gui.Color(color)

    def current_color(self) -> gui.Color:
        return gui.Color(self.currentColor())

    def get_qcolorshower(self) -> QtWidgets.QWidget:
        return [
            a
            for a in self.children()
            if hasattr(a, "metaObject") and a.metaObject().className() == "QColorShower"
        ][0]

    def get_qcolorshowlabel(self) -> QtWidgets.QFrame:
        qcs = self.get_qcolorshower()
        return [
            b
            for b in qcs.children()
            if hasattr(b, "metaObject")
            and b.metaObject().className() == "QColorShowLabel"
        ][0]

    def replace_qcolorshowlabel(self, widget: QtWidgets.QWidget):
        # Find the dialog widget used to display the current
        # color, so we can replace it with our implementation
        qcs = self.get_qcolorshower()
        qcsl = self.get_qcolorshowlabel()
        qcs.layout().replaceWidget(qcsl, widget)
        # Make sure it doesn't receive signals while hidden
        qcsl.blockSignals(True)
        qcsl.hide()
        widget.show()

current_color() -> gui.Color

Source code in prettyqt\widgets\colordialog.py
def current_color(self) -> gui.Color:
    return gui.Color(self.currentColor())

get_color(preset: datatypes.ColorType = None, allow_alpha: bool = False, parent: QtWidgets.QWidget | None = None) -> gui.Color classmethod

Source code in prettyqt\widgets\colordialog.py
@classmethod
def get_color(
    cls,
    preset: datatypes.ColorType = None,
    allow_alpha: bool = False,
    parent: QtWidgets.QWidget | None = None,
) -> gui.Color:
    preset = colors.get_color(preset)
    kwargs = (
        dict(options=cls.ColorDialogOption.ShowAlphaChannel) if allow_alpha else {}
    )
    color = cls.getColor(preset, parent, **kwargs)  # type: ignore
    return gui.Color(color)

get_qcolorshower() -> QtWidgets.QWidget

Source code in prettyqt\widgets\colordialog.py
def get_qcolorshower(self) -> QtWidgets.QWidget:
    return [
        a
        for a in self.children()
        if hasattr(a, "metaObject") and a.metaObject().className() == "QColorShower"
    ][0]

get_qcolorshowlabel() -> QtWidgets.QFrame

Source code in prettyqt\widgets\colordialog.py
def get_qcolorshowlabel(self) -> QtWidgets.QFrame:
    qcs = self.get_qcolorshower()
    return [
        b
        for b in qcs.children()
        if hasattr(b, "metaObject")
        and b.metaObject().className() == "QColorShowLabel"
    ][0]

replace_qcolorshowlabel(widget: QtWidgets.QWidget)

Source code in prettyqt\widgets\colordialog.py
def replace_qcolorshowlabel(self, widget: QtWidgets.QWidget):
    # Find the dialog widget used to display the current
    # color, so we can replace it with our implementation
    qcs = self.get_qcolorshower()
    qcsl = self.get_qcolorshowlabel()
    qcs.layout().replaceWidget(qcsl, widget)
    # Make sure it doesn't receive signals while hidden
    qcsl.blockSignals(True)
    qcsl.hide()
    widget.show()

ColumnView

Bases: widgets.AbstractItemViewMixin, QtWidgets.QColumnView

Source code in prettyqt\widgets\columnview.py
class ColumnView(widgets.AbstractItemViewMixin, QtWidgets.QColumnView):
    pass

ComboBox

Bases: ComboBoxMixin, QtWidgets.QComboBox

Source code in prettyqt\widgets\combobox.py
class ComboBox(ComboBoxMixin, QtWidgets.QComboBox):
    pass

ComboBoxMixin

Bases: widgets.WidgetMixin

Source code in prettyqt\widgets\combobox.py
class ComboBoxMixin(widgets.WidgetMixin):
    value_changed = core.Signal(object)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.currentIndexChanged.connect(self.index_changed)

    # def serialize_fields(self):
    #     items = [
    #         (self.itemText(i), self.itemData(i), self.item_icon(i))
    #         for i in range(self.count())
    #     ]
    #     return dict(
    #         index=self.currentIndex(),
    #         editable=self.isEditable(),
    #         max_count=self.maxCount(),
    #         has_frame=self.hasFrame(),
    #         icon_size=self.iconSize(),
    #         insert_policy=self.insertPolicy(),
    #         model_column=self.modelColumn(),
    #         max_visible_items=self.maxVisibleItems(),
    #         size_adjust_policy=self.get_size_adjust_policy(),
    #         duplicates_enabled=self.duplicatesEnabled(),
    #         min_contents_length=self.minimumContentsLength(),
    #         placeholder_text=self.placeholderText(),
    #         items=items,
    #     )

    # def __setstate__(self, state):
    #     super().__setstate__(state)
    #     for label, data, icon in state["items"]:
    #         self.add(label, data, icon=icon)
    #     self.setCurrentIndex(state["index"])
    #     self.setEditable(state["editable"])
    #     self.setMaxCount(state["max_count"])
    #     self.setMaxVisibleItems(state["max_visible_items"])
    #     self.setMinimumContentsLength(state["min_contents_length"])
    #     self.setDuplicatesEnabled(state["duplicates_enabled"])
    #     self.setFrame(state["has_frame"])

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    def __len__(self) -> int:
        return self.count()

    def index_changed(self, index: int):
        data = self.itemData(index)
        self.value_changed.emit(data)

    def add_items(self, items: Iterable | Mapping, default=NoData):
        if isinstance(items, Mapping):
            for k, v in items.items():
                self.addItem(v, userData=k)
        else:
            for i in items:
                if isinstance(i, tuple | list):
                    self.add(*i)
                else:
                    self.addItem(i, i)
        if default is not NoData:
            self.set_value(default)

    def add(self, label: str, data=NoData, icon: datatypes.IconType = None):
        if data is NoData:
            data = label
        if icon is not None:
            icon = iconprovider.get_icon(icon)
            self.addItem(gui.Icon(icon), label, userData=data)
        else:
            self.addItem(label, userData=data)

    def item_icon(self, index: int) -> gui.Icon | None:
        icon = self.itemIcon(index)
        return None if icon.isNull() else gui.Icon(icon)

    def set_editable(self, editable: bool):
        self.setEditable(editable)
        if self.completer() is None and editable:
            self.setCompleter(widgets.Completer(self))

    def set_insert_policy(self, policy: InsertPolicyStr):
        """Set insert policy.

        Args:
            policy: insert policy to use

        Raises:
            InvalidParamError: invalid insert policy
        """
        if policy not in INSERT_POLICY:
            raise InvalidParamError(policy, INSERT_POLICY)
        self.setInsertPolicy(INSERT_POLICY[policy])

    def get_insert_policy(self) -> InsertPolicyStr:
        """Return insert policy.

        Returns:
            insert policy
        """
        return INSERT_POLICY.inverse[self.insertPolicy()]

    def set_size_adjust_policy(self, policy: SizeAdjustPolicyStr):
        """Set size adjust policy.

        Args:
            policy: size adjust policy to use

        Raises:
            InvalidParamError: invalid size adjust policy
        """
        if policy not in SIZE_ADJUST_POLICY:
            raise InvalidParamError(policy, SIZE_ADJUST_POLICY)
        self.setSizeAdjustPolicy(SIZE_ADJUST_POLICY[policy])

    def get_size_adjust_policy(self) -> SizeAdjustPolicyStr:
        """Return size adjust policy.

        Returns:
            size adjust policy
        """
        return SIZE_ADJUST_POLICY.inverse[self.sizeAdjustPolicy()]

    def set_icon_size(self, size: int | datatypes.SizeType):
        """Set size of the icons."""
        if isinstance(size, int):
            size = core.Size(size, size)
        elif isinstance(size, tuple):
            size = core.Size(*size)
        self.setIconSize(size)

    def get_icon_size(self) -> core.Size:
        return core.Size(self.iconSize())

    def set_min_char_length(self, chars: int):
        self.setMinimumContentsLength(chars)

    def get_value(self) -> Any:
        # if all(self.itemData(i) is None for i in range(self.count())):
        #     return self.currentText()
        # else:
        #     return self.currentData()
        return self.currentData()

    def set_value(self, value: Any):
        self.set_data(value)

    def set_text(self, text: str):
        self.setCurrentText(text)

    def set_data(self, data: Any):
        idx = self.findData(data)
        if idx == -1:
            raise ValueError("invalid data")
        self.setCurrentIndex(idx)

    def text(self) -> str:
        return self.currentText()

    def hide_completer(self):
        """Hides the completion widget."""
        completer = widgets.Completer(self)
        self.setCompleter(completer)

value_changed = core.Signal(object) class-attribute

__init__(*args, **kwargs)

Source code in prettyqt\widgets\combobox.py
def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.currentIndexChanged.connect(self.index_changed)

__len__() -> int

Source code in prettyqt\widgets\combobox.py
def __len__(self) -> int:
    return self.count()

add(label: str, data = NoData, icon: datatypes.IconType = None)

Source code in prettyqt\widgets\combobox.py
def add(self, label: str, data=NoData, icon: datatypes.IconType = None):
    if data is NoData:
        data = label
    if icon is not None:
        icon = iconprovider.get_icon(icon)
        self.addItem(gui.Icon(icon), label, userData=data)
    else:
        self.addItem(label, userData=data)

add_items(items: Iterable | Mapping, default = NoData)

Source code in prettyqt\widgets\combobox.py
def add_items(self, items: Iterable | Mapping, default=NoData):
    if isinstance(items, Mapping):
        for k, v in items.items():
            self.addItem(v, userData=k)
    else:
        for i in items:
            if isinstance(i, tuple | list):
                self.add(*i)
            else:
                self.addItem(i, i)
    if default is not NoData:
        self.set_value(default)

get_icon_size() -> core.Size

Source code in prettyqt\widgets\combobox.py
def get_icon_size(self) -> core.Size:
    return core.Size(self.iconSize())

get_insert_policy() -> InsertPolicyStr

Return insert policy.

Returns:

Type Description
InsertPolicyStr

insert policy

Source code in prettyqt\widgets\combobox.py
def get_insert_policy(self) -> InsertPolicyStr:
    """Return insert policy.

    Returns:
        insert policy
    """
    return INSERT_POLICY.inverse[self.insertPolicy()]

get_size_adjust_policy() -> SizeAdjustPolicyStr

Return size adjust policy.

Returns:

Type Description
SizeAdjustPolicyStr

size adjust policy

Source code in prettyqt\widgets\combobox.py
def get_size_adjust_policy(self) -> SizeAdjustPolicyStr:
    """Return size adjust policy.

    Returns:
        size adjust policy
    """
    return SIZE_ADJUST_POLICY.inverse[self.sizeAdjustPolicy()]

get_value() -> Any

Source code in prettyqt\widgets\combobox.py
def get_value(self) -> Any:
    # if all(self.itemData(i) is None for i in range(self.count())):
    #     return self.currentText()
    # else:
    #     return self.currentData()
    return self.currentData()

hide_completer()

Hides the completion widget.

Source code in prettyqt\widgets\combobox.py
def hide_completer(self):
    """Hides the completion widget."""
    completer = widgets.Completer(self)
    self.setCompleter(completer)

index_changed(index: int)

Source code in prettyqt\widgets\combobox.py
def index_changed(self, index: int):
    data = self.itemData(index)
    self.value_changed.emit(data)

item_icon(index: int) -> gui.Icon | None

Source code in prettyqt\widgets\combobox.py
def item_icon(self, index: int) -> gui.Icon | None:
    icon = self.itemIcon(index)
    return None if icon.isNull() else gui.Icon(icon)

set_data(data: Any)

Source code in prettyqt\widgets\combobox.py
def set_data(self, data: Any):
    idx = self.findData(data)
    if idx == -1:
        raise ValueError("invalid data")
    self.setCurrentIndex(idx)

set_editable(editable: bool)

Source code in prettyqt\widgets\combobox.py
def set_editable(self, editable: bool):
    self.setEditable(editable)
    if self.completer() is None and editable:
        self.setCompleter(widgets.Completer(self))

set_icon_size(size: int | datatypes.SizeType)

Set size of the icons.

Source code in prettyqt\widgets\combobox.py
def set_icon_size(self, size: int | datatypes.SizeType):
    """Set size of the icons."""
    if isinstance(size, int):
        size = core.Size(size, size)
    elif isinstance(size, tuple):
        size = core.Size(*size)
    self.setIconSize(size)

set_insert_policy(policy: InsertPolicyStr)

Set insert policy.

Parameters:

Name Type Description Default
policy InsertPolicyStr

insert policy to use

required

Raises:

Type Description
InvalidParamError

invalid insert policy

Source code in prettyqt\widgets\combobox.py
def set_insert_policy(self, policy: InsertPolicyStr):
    """Set insert policy.

    Args:
        policy: insert policy to use

    Raises:
        InvalidParamError: invalid insert policy
    """
    if policy not in INSERT_POLICY:
        raise InvalidParamError(policy, INSERT_POLICY)
    self.setInsertPolicy(INSERT_POLICY[policy])

set_min_char_length(chars: int)

Source code in prettyqt\widgets\combobox.py
def set_min_char_length(self, chars: int):
    self.setMinimumContentsLength(chars)

set_size_adjust_policy(policy: SizeAdjustPolicyStr)

Set size adjust policy.

Parameters:

Name Type Description Default
policy SizeAdjustPolicyStr

size adjust policy to use

required

Raises:

Type Description
InvalidParamError

invalid size adjust policy

Source code in prettyqt\widgets\combobox.py
def set_size_adjust_policy(self, policy: SizeAdjustPolicyStr):
    """Set size adjust policy.

    Args:
        policy: size adjust policy to use

    Raises:
        InvalidParamError: invalid size adjust policy
    """
    if policy not in SIZE_ADJUST_POLICY:
        raise InvalidParamError(policy, SIZE_ADJUST_POLICY)
    self.setSizeAdjustPolicy(SIZE_ADJUST_POLICY[policy])

set_text(text: str)

Source code in prettyqt\widgets\combobox.py
def set_text(self, text: str):
    self.setCurrentText(text)

set_value(value: Any)

Source code in prettyqt\widgets\combobox.py
def set_value(self, value: Any):
    self.set_data(value)

text() -> str

Source code in prettyqt\widgets\combobox.py
def text(self) -> str:
    return self.currentText()

CommandLinkButton

Bases: widgets.PushButtonMixin, QtWidgets.QCommandLinkButton

Source code in prettyqt\widgets\commandlinkbutton.py
class CommandLinkButton(widgets.PushButtonMixin, QtWidgets.QCommandLinkButton):
    value_changed = core.Signal(bool)

value_changed = core.Signal(bool) class-attribute

CommonStyle

Bases: CommonStyleMixin, QtWidgets.QCommonStyle

Source code in prettyqt\widgets\commonstyle.py
class CommonStyle(CommonStyleMixin, QtWidgets.QCommonStyle):
    pass

CommonStyleMixin

Bases: widgets.StyleMixin

Source code in prettyqt\widgets\commonstyle.py
class CommonStyleMixin(widgets.StyleMixin):
    pass

Completer

Bases: core.ObjectMixin, QtWidgets.QCompleter

Source code in prettyqt\widgets\completer.py
class Completer(core.ObjectMixin, QtWidgets.QCompleter):
    def __init__(self, parent: QtWidgets.QWidget | None = None):
        super().__init__(parent)

    def set_sort_mode(self, mode: SortModeStr | None):
        """Set sort mode to use.

        Args:
            mode: sort mode to use

        Raises:
            InvalidParamError: sort mode does not exist
        """
        if mode is None:
            mode = "unsorted"
        if mode not in SORT_MODE:
            raise InvalidParamError(mode, SORT_MODE)
        self.setModelSorting(SORT_MODE[mode])

    def get_sort_mode(self) -> SortModeStr:
        """Return current sort mode.

        Returns:
            sort mode
        """
        return SORT_MODE.inverse[self.modelSorting()]

    def set_completion_mode(self, mode: CompletionModeStr):
        """Set completion mode to use.

        Args:
            mode: completion mode to use

        Raises:
            InvalidParamError: completion mode does not exist
        """
        if mode not in COMPLETION_MODE:
            raise InvalidParamError(mode, COMPLETION_MODE)
        self.setCompletionMode(COMPLETION_MODE[mode])

    def get_completion_mode(self) -> CompletionModeStr:
        """Return current completion mode.

        Returns:
            completion mode
        """
        return COMPLETION_MODE.inverse[self.completionMode()]

    def set_filter_mode(self, mode: constants.FilterModeStr):
        """Set filter mode to use.

        Args:
            mode: filter mode to use

        Raises:
            InvalidParamError: filter mode does not exist
        """
        if mode not in constants.FILTER_MODES:
            raise InvalidParamError(mode, constants.FILTER_MODES)
        self.setFilterMode(constants.FILTER_MODES[mode])

    def get_filter_mode(self) -> constants.FilterModeStr:
        """Return current filter mode.

        Returns:
            filter mode
        """
        return constants.FILTER_MODES.inverse[self.filterMode()]

    def set_case_sensitive(self, state: bool):
        """Set case sensitivity.

        Args:
            state: case sensitive

        """
        sensitivity = (
            QtCore.Qt.CaseSensitivity.CaseSensitive
            if state
            else QtCore.Qt.CaseSensitivity.CaseInsensitive
        )
        self.setCaseSensitivity(sensitivity)

    def is_case_sensitive(self) -> bool:
        """Return case sensitivity.

        Returns:
            case sensitivity
        """
        return bool(self.caseSensitivity())

__init__(parent: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\completer.py
def __init__(self, parent: QtWidgets.QWidget | None = None):
    super().__init__(parent)

get_completion_mode() -> CompletionModeStr

Return current completion mode.

Returns:

Type Description
CompletionModeStr

completion mode

Source code in prettyqt\widgets\completer.py
def get_completion_mode(self) -> CompletionModeStr:
    """Return current completion mode.

    Returns:
        completion mode
    """
    return COMPLETION_MODE.inverse[self.completionMode()]

get_filter_mode() -> constants.FilterModeStr

Return current filter mode.

Returns:

Type Description
constants.FilterModeStr

filter mode

Source code in prettyqt\widgets\completer.py
def get_filter_mode(self) -> constants.FilterModeStr:
    """Return current filter mode.

    Returns:
        filter mode
    """
    return constants.FILTER_MODES.inverse[self.filterMode()]

get_sort_mode() -> SortModeStr

Return current sort mode.

Returns:

Type Description
SortModeStr

sort mode

Source code in prettyqt\widgets\completer.py
def get_sort_mode(self) -> SortModeStr:
    """Return current sort mode.

    Returns:
        sort mode
    """
    return SORT_MODE.inverse[self.modelSorting()]

is_case_sensitive() -> bool

Return case sensitivity.

Returns:

Type Description
bool

case sensitivity

Source code in prettyqt\widgets\completer.py
def is_case_sensitive(self) -> bool:
    """Return case sensitivity.

    Returns:
        case sensitivity
    """
    return bool(self.caseSensitivity())

set_case_sensitive(state: bool)

Set case sensitivity.

Parameters:

Name Type Description Default
state bool

case sensitive

required
Source code in prettyqt\widgets\completer.py
def set_case_sensitive(self, state: bool):
    """Set case sensitivity.

    Args:
        state: case sensitive

    """
    sensitivity = (
        QtCore.Qt.CaseSensitivity.CaseSensitive
        if state
        else QtCore.Qt.CaseSensitivity.CaseInsensitive
    )
    self.setCaseSensitivity(sensitivity)

set_completion_mode(mode: CompletionModeStr)

Set completion mode to use.

Parameters:

Name Type Description Default
mode CompletionModeStr

completion mode to use

required

Raises:

Type Description
InvalidParamError

completion mode does not exist

Source code in prettyqt\widgets\completer.py
def set_completion_mode(self, mode: CompletionModeStr):
    """Set completion mode to use.

    Args:
        mode: completion mode to use

    Raises:
        InvalidParamError: completion mode does not exist
    """
    if mode not in COMPLETION_MODE:
        raise InvalidParamError(mode, COMPLETION_MODE)
    self.setCompletionMode(COMPLETION_MODE[mode])

set_filter_mode(mode: constants.FilterModeStr)

Set filter mode to use.

Parameters:

Name Type Description Default
mode constants.FilterModeStr

filter mode to use

required

Raises:

Type Description
InvalidParamError

filter mode does not exist

Source code in prettyqt\widgets\completer.py
def set_filter_mode(self, mode: constants.FilterModeStr):
    """Set filter mode to use.

    Args:
        mode: filter mode to use

    Raises:
        InvalidParamError: filter mode does not exist
    """
    if mode not in constants.FILTER_MODES:
        raise InvalidParamError(mode, constants.FILTER_MODES)
    self.setFilterMode(constants.FILTER_MODES[mode])

set_sort_mode(mode: SortModeStr | None)

Set sort mode to use.

Parameters:

Name Type Description Default
mode SortModeStr | None

sort mode to use

required

Raises:

Type Description
InvalidParamError

sort mode does not exist

Source code in prettyqt\widgets\completer.py
def set_sort_mode(self, mode: SortModeStr | None):
    """Set sort mode to use.

    Args:
        mode: sort mode to use

    Raises:
        InvalidParamError: sort mode does not exist
    """
    if mode is None:
        mode = "unsorted"
    if mode not in SORT_MODE:
        raise InvalidParamError(mode, SORT_MODE)
    self.setModelSorting(SORT_MODE[mode])

DataWidgetMapper

Bases: core.ObjectMixin, QtWidgets.QDataWidgetMapper

Source code in prettyqt\widgets\datawidgetmapper.py
class DataWidgetMapper(core.ObjectMixin, QtWidgets.QDataWidgetMapper):
    def set_orientation(self, orientation: constants.OrientationStr):
        """Set the orientation of the data widget mapper.

        Args:
            orientation: orientation for the data widget mapper

        Raises:
            InvalidParamError: orientation does not exist
        """
        if orientation not in constants.ORIENTATION:
            raise InvalidParamError(orientation, constants.ORIENTATION)
        self.setOrientation(constants.ORIENTATION[orientation])

    def get_orientation(self) -> constants.OrientationStr:
        """Return current orientation.

        Returns:
            orientation
        """
        return constants.ORIENTATION.inverse[self.orientation()]

    def set_submit_policy(self, policy: SubmitPolicyStr):
        """Set the submit policy of the mapper.

        Args:
            policy: submit_policy for the data widget mapper

        Raises:
            InvalidParamError: submit_policy does not exist
        """
        if policy not in SUBMIT_POLICY:
            raise InvalidParamError(policy, SUBMIT_POLICY)
        self.setSubmitPolicy(SUBMIT_POLICY[policy])

    def get_submit_policy(self) -> SubmitPolicyStr:
        """Return current submit policy.

        Returns:
            submit policy
        """
        return SUBMIT_POLICY.inverse[self.submitPolicy()]

    def add_mapping(
        self, widget: QtWidgets.QWidget, section: int, property_name: str | None = None
    ):
        if property_name is None:
            self.addMapping(widget, section)
        else:
            ba = QtCore.QByteArray(property_name.encode())
            self.addMapping(widget, section, ba)

    def get_mapped_property_name(self, widget: QtWidgets.QWidget) -> str:
        return self.mappedPropertyName(widget).data().decode()

add_mapping(widget: QtWidgets.QWidget, section: int, property_name: str | None = None)

Source code in prettyqt\widgets\datawidgetmapper.py
def add_mapping(
    self, widget: QtWidgets.QWidget, section: int, property_name: str | None = None
):
    if property_name is None:
        self.addMapping(widget, section)
    else:
        ba = QtCore.QByteArray(property_name.encode())
        self.addMapping(widget, section, ba)

get_mapped_property_name(widget: QtWidgets.QWidget) -> str

Source code in prettyqt\widgets\datawidgetmapper.py
def get_mapped_property_name(self, widget: QtWidgets.QWidget) -> str:
    return self.mappedPropertyName(widget).data().decode()

get_orientation() -> constants.OrientationStr

Return current orientation.

Returns:

Type Description
constants.OrientationStr

orientation

Source code in prettyqt\widgets\datawidgetmapper.py
def get_orientation(self) -> constants.OrientationStr:
    """Return current orientation.

    Returns:
        orientation
    """
    return constants.ORIENTATION.inverse[self.orientation()]

get_submit_policy() -> SubmitPolicyStr

Return current submit policy.

Returns:

Type Description
SubmitPolicyStr

submit policy

Source code in prettyqt\widgets\datawidgetmapper.py
def get_submit_policy(self) -> SubmitPolicyStr:
    """Return current submit policy.

    Returns:
        submit policy
    """
    return SUBMIT_POLICY.inverse[self.submitPolicy()]

set_orientation(orientation: constants.OrientationStr)

Set the orientation of the data widget mapper.

Parameters:

Name Type Description Default
orientation constants.OrientationStr

orientation for the data widget mapper

required

Raises:

Type Description
InvalidParamError

orientation does not exist

Source code in prettyqt\widgets\datawidgetmapper.py
def set_orientation(self, orientation: constants.OrientationStr):
    """Set the orientation of the data widget mapper.

    Args:
        orientation: orientation for the data widget mapper

    Raises:
        InvalidParamError: orientation does not exist
    """
    if orientation not in constants.ORIENTATION:
        raise InvalidParamError(orientation, constants.ORIENTATION)
    self.setOrientation(constants.ORIENTATION[orientation])

set_submit_policy(policy: SubmitPolicyStr)

Set the submit policy of the mapper.

Parameters:

Name Type Description Default
policy SubmitPolicyStr

submit_policy for the data widget mapper

required

Raises:

Type Description
InvalidParamError

submit_policy does not exist

Source code in prettyqt\widgets\datawidgetmapper.py
def set_submit_policy(self, policy: SubmitPolicyStr):
    """Set the submit policy of the mapper.

    Args:
        policy: submit_policy for the data widget mapper

    Raises:
        InvalidParamError: submit_policy does not exist
    """
    if policy not in SUBMIT_POLICY:
        raise InvalidParamError(policy, SUBMIT_POLICY)
    self.setSubmitPolicy(SUBMIT_POLICY[policy])

DateEdit

Bases: widgets.DateTimeEditMixin, QtWidgets.QDateEdit

Source code in prettyqt\widgets\dateedit.py
class DateEdit(widgets.DateTimeEditMixin, QtWidgets.QDateEdit):
    value_changed = core.Signal(datetime.datetime)

    def set_value(self, value: datatypes.DateType):
        if isinstance(value, str):
            value = QtCore.QDate.fromString(value)
        self.setDate(value)  # type: ignore

    def set_range(self, lower: datatypes.DateType, upper: datatypes.DateType):
        if isinstance(lower, str):
            lower = QtCore.QDate.fromString(lower)
        if isinstance(upper, str):
            upper = QtCore.QDate.fromString(upper)
        self.setToolTip(f"{lower} <= x <= {upper}")
        self.setDateRange(lower, upper)  # type: ignore

    def get_value(self) -> datetime.date:
        return self.get_date()

value_changed = core.Signal(datetime.datetime) class-attribute

get_value() -> datetime.date

Source code in prettyqt\widgets\dateedit.py
def get_value(self) -> datetime.date:
    return self.get_date()

set_range(lower: datatypes.DateType, upper: datatypes.DateType)

Source code in prettyqt\widgets\dateedit.py
def set_range(self, lower: datatypes.DateType, upper: datatypes.DateType):
    if isinstance(lower, str):
        lower = QtCore.QDate.fromString(lower)
    if isinstance(upper, str):
        upper = QtCore.QDate.fromString(upper)
    self.setToolTip(f"{lower} <= x <= {upper}")
    self.setDateRange(lower, upper)  # type: ignore

set_value(value: datatypes.DateType)

Source code in prettyqt\widgets\dateedit.py
def set_value(self, value: datatypes.DateType):
    if isinstance(value, str):
        value = QtCore.QDate.fromString(value)
    self.setDate(value)  # type: ignore

DateTimeEdit

Bases: DateTimeEditMixin, QtWidgets.QDateTimeEdit

Source code in prettyqt\widgets\datetimeedit.py
class DateTimeEdit(DateTimeEditMixin, QtWidgets.QDateTimeEdit):
    pass

DateTimeEditMixin

Bases: widgets.AbstractSpinBoxMixin

Source code in prettyqt\widgets\datetimeedit.py
class DateTimeEditMixin(widgets.AbstractSpinBoxMixin):
    value_changed = core.Signal(datetime.datetime)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.setCalendarPopup(True)
        self.dateTimeChanged.connect(self.datetime_changed)

    def datetime_changed(self, date):
        dt = self.get_datetime()
        self.value_changed.emit(dt)

    def get_section_text(self, section: SectionsStr) -> str:
        if section not in SECTIONS:
            raise InvalidParamError(section, SECTIONS)
        return self.sectionText(SECTIONS[section])

    def get_current_section(self) -> SectionsStr:
        return SECTIONS.inverse[self.currentSection()]

    def set_current_section(self, section: SectionsStr):
        if section not in SECTIONS:
            raise InvalidParamError(section, SECTIONS)
        self.setCurrentSection(SECTIONS[section])

    def get_displayed_sections(self) -> list[SectionsStr]:
        return SECTIONS.get_list(self.displayedSections())

    def set_range(
        self,
        lower: datatypes.DateTimeType,
        upper: datatypes.DateTimeType,
    ):
        if isinstance(lower, str):
            lower = dateutil.parser.parse(lower)
        if isinstance(upper, str):
            upper = dateutil.parser.parse(upper)
        self.setToolTip(f"{lower} <= x <= {upper}")
        self.setDateTimeRange(lower, upper)  # type: ignore

    def set_format(self, fmt: str):
        self.setDisplayFormat(fmt)

    def get_value(self) -> datetime.datetime:
        return self.get_datetime()

    def set_value(self, value: datetime.datetime):
        self.setDateTime(value)  # type: ignore

    def get_datetime(self) -> datetime.datetime:
        return self.dateTime().toPython()  # type: ignore

    def min_datetime(self) -> datetime.datetime:
        return self.minimumDateTime().toPython()  # type: ignore

    def max_datetime(self) -> datetime.datetime:
        return self.maximumDateTime().toPython()  # type: ignore

    def min_date(self) -> datetime.date:
        return self.minimumDate().toPython()  # type: ignore

    def max_date(self) -> datetime.date:
        return self.maximumDate().toPython()  # type: ignore

    def get_date(self) -> datetime.date:
        return self.date().toPython()  # type: ignore

    def min_time(self) -> datetime.time:
        return self.minimumTime().toPython()  # type: ignore

    def max_time(self) -> datetime.time:
        return self.maximumTime().toPython()  # type: ignore

    def get_time(self) -> datetime.time:
        return self.time().toPython()  # type: ignore

value_changed = core.Signal(datetime.datetime) class-attribute

__init__(*args, **kwargs)

Source code in prettyqt\widgets\datetimeedit.py
def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.setCalendarPopup(True)
    self.dateTimeChanged.connect(self.datetime_changed)

datetime_changed(date)

Source code in prettyqt\widgets\datetimeedit.py
def datetime_changed(self, date):
    dt = self.get_datetime()
    self.value_changed.emit(dt)

get_current_section() -> SectionsStr

Source code in prettyqt\widgets\datetimeedit.py
def get_current_section(self) -> SectionsStr:
    return SECTIONS.inverse[self.currentSection()]

get_date() -> datetime.date

Source code in prettyqt\widgets\datetimeedit.py
def get_date(self) -> datetime.date:
    return self.date().toPython()  # type: ignore

get_datetime() -> datetime.datetime

Source code in prettyqt\widgets\datetimeedit.py
def get_datetime(self) -> datetime.datetime:
    return self.dateTime().toPython()  # type: ignore

get_displayed_sections() -> list[SectionsStr]

Source code in prettyqt\widgets\datetimeedit.py
def get_displayed_sections(self) -> list[SectionsStr]:
    return SECTIONS.get_list(self.displayedSections())

get_section_text(section: SectionsStr) -> str

Source code in prettyqt\widgets\datetimeedit.py
def get_section_text(self, section: SectionsStr) -> str:
    if section not in SECTIONS:
        raise InvalidParamError(section, SECTIONS)
    return self.sectionText(SECTIONS[section])

get_time() -> datetime.time

Source code in prettyqt\widgets\datetimeedit.py
def get_time(self) -> datetime.time:
    return self.time().toPython()  # type: ignore

get_value() -> datetime.datetime

Source code in prettyqt\widgets\datetimeedit.py
def get_value(self) -> datetime.datetime:
    return self.get_datetime()

max_date() -> datetime.date

Source code in prettyqt\widgets\datetimeedit.py
def max_date(self) -> datetime.date:
    return self.maximumDate().toPython()  # type: ignore

max_datetime() -> datetime.datetime

Source code in prettyqt\widgets\datetimeedit.py
def max_datetime(self) -> datetime.datetime:
    return self.maximumDateTime().toPython()  # type: ignore

max_time() -> datetime.time

Source code in prettyqt\widgets\datetimeedit.py
def max_time(self) -> datetime.time:
    return self.maximumTime().toPython()  # type: ignore

min_date() -> datetime.date

Source code in prettyqt\widgets\datetimeedit.py
def min_date(self) -> datetime.date:
    return self.minimumDate().toPython()  # type: ignore

min_datetime() -> datetime.datetime

Source code in prettyqt\widgets\datetimeedit.py
def min_datetime(self) -> datetime.datetime:
    return self.minimumDateTime().toPython()  # type: ignore

min_time() -> datetime.time

Source code in prettyqt\widgets\datetimeedit.py
def min_time(self) -> datetime.time:
    return self.minimumTime().toPython()  # type: ignore

set_current_section(section: SectionsStr)

Source code in prettyqt\widgets\datetimeedit.py
def set_current_section(self, section: SectionsStr):
    if section not in SECTIONS:
        raise InvalidParamError(section, SECTIONS)
    self.setCurrentSection(SECTIONS[section])

set_format(fmt: str)

Source code in prettyqt\widgets\datetimeedit.py
def set_format(self, fmt: str):
    self.setDisplayFormat(fmt)

set_range(lower: datatypes.DateTimeType, upper: datatypes.DateTimeType)

Source code in prettyqt\widgets\datetimeedit.py
def set_range(
    self,
    lower: datatypes.DateTimeType,
    upper: datatypes.DateTimeType,
):
    if isinstance(lower, str):
        lower = dateutil.parser.parse(lower)
    if isinstance(upper, str):
        upper = dateutil.parser.parse(upper)
    self.setToolTip(f"{lower} <= x <= {upper}")
    self.setDateTimeRange(lower, upper)  # type: ignore

set_value(value: datetime.datetime)

Source code in prettyqt\widgets\datetimeedit.py
def set_value(self, value: datetime.datetime):
    self.setDateTime(value)  # type: ignore

Dial

Bases: widgets.AbstractSliderMixin, QtWidgets.QDial

Source code in prettyqt\widgets\dial.py
class Dial(widgets.AbstractSliderMixin, QtWidgets.QDial):
    value_changed = core.Signal(int)

    def __init__(self, parent: QtWidgets.QWidget | None = None):
        super().__init__(parent)
        self.valueChanged.connect(self.on_value_change)

value_changed = core.Signal(int) class-attribute

__init__(parent: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\dial.py
def __init__(self, parent: QtWidgets.QWidget | None = None):
    super().__init__(parent)
    self.valueChanged.connect(self.on_value_change)

Dialog

Bases: DialogMixin, QtWidgets.QDialog

Source code in prettyqt\widgets\dialog.py
class Dialog(DialogMixin, QtWidgets.QDialog):
    pass

DialogButtonBox

Bases: widgets.WidgetMixin, QtWidgets.QDialogButtonBox

Source code in prettyqt\widgets\dialogbuttonbox.py
class DialogButtonBox(widgets.WidgetMixin, QtWidgets.QDialogButtonBox):
    button_clicked = core.Signal(str)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.clicked.connect(self.on_click)

    def __len__(self) -> int:
        return len(self.buttons())

    def __getitem__(self, index: ButtonStr) -> QtWidgets.QPushButton:
        return self.button(BUTTONS[index])

    def __iter__(self) -> Iterator[QtWidgets.QAbstractButton]:
        return iter(self.buttons())

    def __contains__(self, index: ButtonStr):
        return self.button(BUTTONS[index]) is not None

    @classmethod
    def create(cls, **kwargs):
        box = cls()
        for k, v in kwargs.items():
            box.add_default_button(k, callback=v)  # type: ignore
        return box

    def on_click(self, button: QtCore.QObject):
        self.button_clicked.emit(button.objectName())

    def set_horizontal(self):
        self.setOrientation(constants.HORIZONTAL)

    def set_vertical(self):
        self.setOrientation(constants.VERTICAL)

    def set_orientation(self, orientation: constants.OrientationStr):
        """Set the orientation of the button box.

        Args:
            orientation: orientation for the button box

        Raises:
            InvalidParamError: orientation does not exist
        """
        if orientation not in constants.ORIENTATION:
            raise InvalidParamError(orientation, constants.ORIENTATION)
        self.setOrientation(constants.ORIENTATION[orientation])

    def get_orientation(self) -> constants.OrientationStr:
        """Return current orientation.

        Returns:
            orientation
        """
        return constants.ORIENTATION.inverse[self.orientation()]

    def add_default_buttons(self, buttons: Sequence[ButtonStr]):
        return [self.add_default_button(btn) for btn in buttons]

    def add_default_button(
        self, button: ButtonStr, callback: Callable | None = None
    ) -> QtWidgets.QPushButton:
        """Add a default button.

        Args:
            button: button to add
            callback: function to call when button gets clicked

        Returns:
            created button

        Raises:
            InvalidParamError: Button type not available
        """
        if button not in BUTTONS:
            raise InvalidParamError(button, BUTTONS)
        btn = self.addButton(BUTTONS[button])
        btn.setObjectName(button)
        if callback:
            btn.clicked.connect(callback)
        return btn

    def add_button(
        self,
        button: QtWidgets.QPushButton | ButtonStr,
        role: RoleStr = "accept",
        callback: Callable | None = None,
    ) -> widgets.PushButton:
        """Add a button.

        Args:
            button: button to add
            role: role of the button
            callback: function to call when button gets clicked

        Returns:
            created button

        Raises:
            InvalidParamError: Button type not available
        """
        if isinstance(button, str):
            button = widgets.PushButton(button)
        self.addButton(button, ROLES[role])
        if callback:
            button.clicked.connect(callback)
        return button

button_clicked = core.Signal(str) class-attribute

__contains__(index: ButtonStr)

Source code in prettyqt\widgets\dialogbuttonbox.py
def __contains__(self, index: ButtonStr):
    return self.button(BUTTONS[index]) is not None

__getitem__(index: ButtonStr) -> QtWidgets.QPushButton

Source code in prettyqt\widgets\dialogbuttonbox.py
def __getitem__(self, index: ButtonStr) -> QtWidgets.QPushButton:
    return self.button(BUTTONS[index])

__init__(*args, **kwargs)

Source code in prettyqt\widgets\dialogbuttonbox.py
def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.clicked.connect(self.on_click)

__iter__() -> Iterator[QtWidgets.QAbstractButton]

Source code in prettyqt\widgets\dialogbuttonbox.py
def __iter__(self) -> Iterator[QtWidgets.QAbstractButton]:
    return iter(self.buttons())

__len__() -> int

Source code in prettyqt\widgets\dialogbuttonbox.py
def __len__(self) -> int:
    return len(self.buttons())

add_button(button: QtWidgets.QPushButton | ButtonStr, role: RoleStr = 'accept', callback: Callable | None = None) -> widgets.PushButton

Add a button.

Parameters:

Name Type Description Default
button QtWidgets.QPushButton | ButtonStr

button to add

required
role RoleStr

role of the button

'accept'
callback Callable | None

function to call when button gets clicked

None

Returns:

Type Description
widgets.PushButton

created button

Raises:

Type Description
InvalidParamError

Button type not available

Source code in prettyqt\widgets\dialogbuttonbox.py
def add_button(
    self,
    button: QtWidgets.QPushButton | ButtonStr,
    role: RoleStr = "accept",
    callback: Callable | None = None,
) -> widgets.PushButton:
    """Add a button.

    Args:
        button: button to add
        role: role of the button
        callback: function to call when button gets clicked

    Returns:
        created button

    Raises:
        InvalidParamError: Button type not available
    """
    if isinstance(button, str):
        button = widgets.PushButton(button)
    self.addButton(button, ROLES[role])
    if callback:
        button.clicked.connect(callback)
    return button

add_default_button(button: ButtonStr, callback: Callable | None = None) -> QtWidgets.QPushButton

Add a default button.

Parameters:

Name Type Description Default
button ButtonStr

button to add

required
callback Callable | None

function to call when button gets clicked

None

Returns:

Type Description
QtWidgets.QPushButton

created button

Raises:

Type Description
InvalidParamError

Button type not available

Source code in prettyqt\widgets\dialogbuttonbox.py
def add_default_button(
    self, button: ButtonStr, callback: Callable | None = None
) -> QtWidgets.QPushButton:
    """Add a default button.

    Args:
        button: button to add
        callback: function to call when button gets clicked

    Returns:
        created button

    Raises:
        InvalidParamError: Button type not available
    """
    if button not in BUTTONS:
        raise InvalidParamError(button, BUTTONS)
    btn = self.addButton(BUTTONS[button])
    btn.setObjectName(button)
    if callback:
        btn.clicked.connect(callback)
    return btn

add_default_buttons(buttons: Sequence[ButtonStr])

Source code in prettyqt\widgets\dialogbuttonbox.py
def add_default_buttons(self, buttons: Sequence[ButtonStr]):
    return [self.add_default_button(btn) for btn in buttons]

create(**kwargs) classmethod

Source code in prettyqt\widgets\dialogbuttonbox.py
@classmethod
def create(cls, **kwargs):
    box = cls()
    for k, v in kwargs.items():
        box.add_default_button(k, callback=v)  # type: ignore
    return box

get_orientation() -> constants.OrientationStr

Return current orientation.

Returns:

Type Description
constants.OrientationStr

orientation

Source code in prettyqt\widgets\dialogbuttonbox.py
def get_orientation(self) -> constants.OrientationStr:
    """Return current orientation.

    Returns:
        orientation
    """
    return constants.ORIENTATION.inverse[self.orientation()]

on_click(button: QtCore.QObject)

Source code in prettyqt\widgets\dialogbuttonbox.py
def on_click(self, button: QtCore.QObject):
    self.button_clicked.emit(button.objectName())

set_horizontal()

Source code in prettyqt\widgets\dialogbuttonbox.py
def set_horizontal(self):
    self.setOrientation(constants.HORIZONTAL)

set_orientation(orientation: constants.OrientationStr)

Set the orientation of the button box.

Parameters:

Name Type Description Default
orientation constants.OrientationStr

orientation for the button box

required

Raises:

Type Description
InvalidParamError

orientation does not exist

Source code in prettyqt\widgets\dialogbuttonbox.py
def set_orientation(self, orientation: constants.OrientationStr):
    """Set the orientation of the button box.

    Args:
        orientation: orientation for the button box

    Raises:
        InvalidParamError: orientation does not exist
    """
    if orientation not in constants.ORIENTATION:
        raise InvalidParamError(orientation, constants.ORIENTATION)
    self.setOrientation(constants.ORIENTATION[orientation])

set_vertical()

Source code in prettyqt\widgets\dialogbuttonbox.py
def set_vertical(self):
    self.setOrientation(constants.VERTICAL)

DialogMixin

Bases: widgets.WidgetMixin

Source code in prettyqt\widgets\dialog.py
class DialogMixin(widgets.WidgetMixin):
    def __init__(
        self,
        title: str = "",
        icon: datatypes.IconType = None,
        parent: QtWidgets.QWidget | None = None,
        delete_on_close: bool = False,
        layout: None | str | QtWidgets.QLayout = None,
    ):
        super().__init__(parent=parent)
        self.set_title(title)
        self.set_icon(icon)
        if delete_on_close:
            self.delete_on_close()
        if layout is not None:
            self.set_layout(layout)

    def __getitem__(self, index: str) -> QtWidgets.QWidget:
        result = self.find_child(QtWidgets.QWidget, index)
        if result is None:
            raise KeyError("Widget not found")
        return result

    def serialize_fields(self):
        return dict(
            # modal=self.isModal(),
            # layout=self.layout(),
            size_grip_enabled=self.isSizeGripEnabled(),
            size=(self.size().width(), self.size().height()),
        )

    def keyPressEvent(self, e):
        match e.key():
            case QtCore.Qt.Key.Key_Escape:
                self.close()
            case QtCore.Qt.Key.Key_F11 if self.isMaximized():
                self.showNormal()
            case QtCore.Qt.Key.Key_F11:
                self.showMaximized()
            case _:
                super().keyPressEvent(e)

    def delete_on_close(self):
        self.setAttribute(QtCore.Qt.WidgetAttribute.WA_DeleteOnClose)

    def add_widget(self, widget: QtWidgets.QWidget) -> QtWidgets.QWidget:
        self.box += widget
        return widget

    def add_buttonbox(self) -> widgets.DialogButtonBox:
        button_box = widgets.DialogButtonBox.create(ok=self.accept, cancel=self.reject)
        self.box.add(button_box)
        return button_box

    def show_blocking(self) -> bool:
        self.show()
        return bool(self.main_loop())

    def is_accepted(self) -> bool:
        return self.result() == QtWidgets.QDialog.DialogCode.Accepted

    def main_loop(self) -> int:
        return self.exec()

__getitem__(index: str) -> QtWidgets.QWidget

Source code in prettyqt\widgets\dialog.py
def __getitem__(self, index: str) -> QtWidgets.QWidget:
    result = self.find_child(QtWidgets.QWidget, index)
    if result is None:
        raise KeyError("Widget not found")
    return result

__init__(title: str = '', icon: datatypes.IconType = None, parent: QtWidgets.QWidget | None = None, delete_on_close: bool = False, layout: None | str | QtWidgets.QLayout = None)

Source code in prettyqt\widgets\dialog.py
def __init__(
    self,
    title: str = "",
    icon: datatypes.IconType = None,
    parent: QtWidgets.QWidget | None = None,
    delete_on_close: bool = False,
    layout: None | str | QtWidgets.QLayout = None,
):
    super().__init__(parent=parent)
    self.set_title(title)
    self.set_icon(icon)
    if delete_on_close:
        self.delete_on_close()
    if layout is not None:
        self.set_layout(layout)

add_buttonbox() -> widgets.DialogButtonBox

Source code in prettyqt\widgets\dialog.py
def add_buttonbox(self) -> widgets.DialogButtonBox:
    button_box = widgets.DialogButtonBox.create(ok=self.accept, cancel=self.reject)
    self.box.add(button_box)
    return button_box

add_widget(widget: QtWidgets.QWidget) -> QtWidgets.QWidget

Source code in prettyqt\widgets\dialog.py
def add_widget(self, widget: QtWidgets.QWidget) -> QtWidgets.QWidget:
    self.box += widget
    return widget

delete_on_close()

Source code in prettyqt\widgets\dialog.py
def delete_on_close(self):
    self.setAttribute(QtCore.Qt.WidgetAttribute.WA_DeleteOnClose)

is_accepted() -> bool

Source code in prettyqt\widgets\dialog.py
def is_accepted(self) -> bool:
    return self.result() == QtWidgets.QDialog.DialogCode.Accepted

keyPressEvent(e)

Source code in prettyqt\widgets\dialog.py
def keyPressEvent(self, e):
    match e.key():
        case QtCore.Qt.Key.Key_Escape:
            self.close()
        case QtCore.Qt.Key.Key_F11 if self.isMaximized():
            self.showNormal()
        case QtCore.Qt.Key.Key_F11:
            self.showMaximized()
        case _:
            super().keyPressEvent(e)

main_loop() -> int

Source code in prettyqt\widgets\dialog.py
def main_loop(self) -> int:
    return self.exec()

serialize_fields()

Source code in prettyqt\widgets\dialog.py
def serialize_fields(self):
    return dict(
        # modal=self.isModal(),
        # layout=self.layout(),
        size_grip_enabled=self.isSizeGripEnabled(),
        size=(self.size().width(), self.size().height()),
    )

show_blocking() -> bool

Source code in prettyqt\widgets\dialog.py
def show_blocking(self) -> bool:
    self.show()
    return bool(self.main_loop())

DockWidget

Bases: widgets.WidgetMixin, QtWidgets.QDockWidget

Customized DockWidget class.

Contains a custom TitleBar with maximize button

Source code in prettyqt\widgets\dockwidget.py
class DockWidget(widgets.WidgetMixin, QtWidgets.QDockWidget):
    """Customized DockWidget class.

    Contains a custom TitleBar with maximize button
    """

    def __init__(self, *args, **kwargs):
        name = kwargs.pop("name", None)
        title = kwargs.pop("title", None)
        super().__init__(*args, **kwargs)
        if name:
            self.set_id(name)
        if title:
            self.set_title(title)
        self.set_allowed_areas("all")

    # def __setstate__(self, state: dict[str, Any]) -> None:
    #     self.set_widget(state["widget"])

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    # def serialize_fields(self) -> dict[str, Any]:
    #     return dict(widget=self.widget())

    def set_widget(self, widget: QtWidgets.QWidget):
        self.setWidget(widget)

    def set_allowed_areas(self, area: constants.DockPositionsStr):
        self.setAllowedAreas(constants.DOCK_POSITIONS[area])

    def setup_title_bar(self):
        title_bar = widgets.Widget()
        layout = widgets.BoxLayout("horizontal")
        layout.set_margin(0)
        layout.set_alignment("right")
        title_bar.set_layout(layout)
        maximize_button = widgets.PushButton()
        layout.add(maximize_button)
        maximize_button.set_style_icon("titlebar_max_button")
        maximize_button.clicked.connect(self.maximize)
        close_button = widgets.PushButton()
        close_button.set_style_icon("titlebar_close_button")
        layout.add(close_button)
        close_button.clicked.connect(self.close)
        self.setTitleBarWidget(title_bar)

    @deprecated(reason="This method is deprecated, use 'maximize' instead.")
    def maximise(self):
        self.maximize()

    def maximize(self):
        if not self.isFloating():
            self.setFloating(True)
        if not self.isMaximized():
            self.showMaximized()
        else:
            self.showMinimized()

__init__(*args, **kwargs)

Source code in prettyqt\widgets\dockwidget.py
def __init__(self, *args, **kwargs):
    name = kwargs.pop("name", None)
    title = kwargs.pop("title", None)
    super().__init__(*args, **kwargs)
    if name:
        self.set_id(name)
    if title:
        self.set_title(title)
    self.set_allowed_areas("all")

maximise()

Source code in prettyqt\widgets\dockwidget.py
@deprecated(reason="This method is deprecated, use 'maximize' instead.")
def maximise(self):
    self.maximize()

maximize()

Source code in prettyqt\widgets\dockwidget.py
def maximize(self):
    if not self.isFloating():
        self.setFloating(True)
    if not self.isMaximized():
        self.showMaximized()
    else:
        self.showMinimized()

set_allowed_areas(area: constants.DockPositionsStr)

Source code in prettyqt\widgets\dockwidget.py
def set_allowed_areas(self, area: constants.DockPositionsStr):
    self.setAllowedAreas(constants.DOCK_POSITIONS[area])

set_widget(widget: QtWidgets.QWidget)

Source code in prettyqt\widgets\dockwidget.py
def set_widget(self, widget: QtWidgets.QWidget):
    self.setWidget(widget)

setup_title_bar()

Source code in prettyqt\widgets\dockwidget.py
def setup_title_bar(self):
    title_bar = widgets.Widget()
    layout = widgets.BoxLayout("horizontal")
    layout.set_margin(0)
    layout.set_alignment("right")
    title_bar.set_layout(layout)
    maximize_button = widgets.PushButton()
    layout.add(maximize_button)
    maximize_button.set_style_icon("titlebar_max_button")
    maximize_button.clicked.connect(self.maximize)
    close_button = widgets.PushButton()
    close_button.set_style_icon("titlebar_close_button")
    layout.add(close_button)
    close_button.clicked.connect(self.close)
    self.setTitleBarWidget(title_bar)

DoubleSpinBox

Bases: widgets.AbstractSpinBoxMixin, QtWidgets.QDoubleSpinBox

Source code in prettyqt\widgets\doublespinbox.py
class DoubleSpinBox(widgets.AbstractSpinBoxMixin, QtWidgets.QDoubleSpinBox):
    value_changed = core.Signal(float)

    def __init__(
        self,
        parent: QtWidgets.QWidget | None = None,
        min_value: float | None = None,
        max_value: float | None = None,
        default_value: float | None = None,
    ):
        super().__init__(parent)
        self.valueChanged.connect(self.value_changed)
        self.set_range(min_value, max_value)
        if default_value is not None:
            self.set_value(default_value)

    def set_range(self, start: float | None, end: float | None):
        if start is None:
            start = -float("inf")
        if end is None:
            end = float("inf")
        self.setRange(start, end)

value_changed = core.Signal(float) class-attribute

__init__(parent: QtWidgets.QWidget | None = None, min_value: float | None = None, max_value: float | None = None, default_value: float | None = None)

Source code in prettyqt\widgets\doublespinbox.py
def __init__(
    self,
    parent: QtWidgets.QWidget | None = None,
    min_value: float | None = None,
    max_value: float | None = None,
    default_value: float | None = None,
):
    super().__init__(parent)
    self.valueChanged.connect(self.value_changed)
    self.set_range(min_value, max_value)
    if default_value is not None:
        self.set_value(default_value)

set_range(start: float | None, end: float | None)

Source code in prettyqt\widgets\doublespinbox.py
def set_range(self, start: float | None, end: float | None):
    if start is None:
        start = -float("inf")
    if end is None:
        end = float("inf")
    self.setRange(start, end)

ErrorMessage

Bases: widgets.DialogMixin, QtWidgets.QErrorMessage

Source code in prettyqt\widgets\errormessage.py
class ErrorMessage(widgets.DialogMixin, QtWidgets.QErrorMessage):
    pass

FileDialog

Bases: widgets.DialogMixin, QtWidgets.QFileDialog

Simple dialog used to display some widget.

Source code in prettyqt\widgets\filedialog.py
class FileDialog(widgets.DialogMixin, QtWidgets.QFileDialog):
    """Simple dialog used to display some widget."""

    def __init__(
        self,
        path: None | datatypes.PathType = None,
        mode: AcceptModeStr = "open",
        caption: str | None = None,
        path_id: str | None = None,
        extension_filter: dict | None = None,
        file_mode: FileModeStr = "existing_files",
        parent: QtWidgets.QWidget | None = None,
    ):
        super().__init__(parent=parent)
        self.set_title(caption)
        self.path_id = path_id
        if extension_filter:
            self.set_extension_filter(extension_filter)
        if path_id is not None and path is None:
            settings = core.Settings()
            path = settings.get(path_id, "")
        if path is not None:
            self.set_directory(path)
        self.set_file_mode(file_mode)
        self.set_accept_mode(mode)

    def set_accept_mode(self, mode: AcceptModeStr):
        """Set accept mode.

        Args:
            mode: accept mode to use

        Raises:
            InvalidParamError: invalid accept mode
        """
        if mode not in ACCEPT_MODE:
            raise InvalidParamError(mode, ACCEPT_MODE)
        self.setAcceptMode(ACCEPT_MODE[mode])

    def get_accept_mode(self) -> AcceptModeStr:
        """Return accept mode.

        Returns:
            accept mode
        """
        return ACCEPT_MODE.inverse[self.acceptMode()]

    def set_view_mode(self, mode: ViewModeStr):
        """Set view mode.

        Args:
            mode: view mode to use

        Raises:
            InvalidParamError: invalid view mode
        """
        if mode not in VIEW_MODE:
            raise InvalidParamError(mode, VIEW_MODE)
        self.setViewMode(VIEW_MODE[mode])

    def get_view_mode(self) -> ViewModeStr:
        """Return view mode.

        Returns:
            view mode
        """
        return VIEW_MODE.inverse[self.viewMode()]

    def set_label_text(self, label: LabelStr, text: str):
        """Set the label text for button label.

        Args:
            label: button to set text for
            text: text to use
        """
        if label not in LABEL:
            raise InvalidParamError(label, LABEL)
        self.setLabelText(LABEL[label], text)

    def get_label_text(self, label: LabelStr) -> str:
        """Return label text.

        Returns:
            label text
        """
        return self.labelText(LABEL[label])

    def get_file_mode(self) -> FileModeStr:
        """Return file mode.

        Returns:
            file mode
        """
        return FILE_MODE.inverse[self.fileMode()]

    def set_file_mode(self, mode: FileModeStr):
        """Set the file mode of the dialog.

        Args:
            mode: mode to use
        """
        self.setFileMode(FILE_MODE[mode])

    def selected_files(self) -> list[pathlib.Path]:
        return [pathlib.Path(p) for p in self.selectedFiles()]

    def selected_file(self) -> pathlib.Path | None:
        selected = self.selectedFiles()
        return pathlib.Path(selected[0]) if selected else None

    def choose_folder(self) -> list[pathlib.Path] | None:
        self.set_file_mode("directory")
        return self.choose()

    def open_file(self) -> list[pathlib.Path] | None:
        self.set_file_mode("existing_file")
        return self.choose()

    def choose(self) -> list[pathlib.Path] | None:
        result = self.main_loop()
        if result != self.DialogCode.Accepted:
            return None
        paths = self.selected_files()
        if self.path_id:
            settings = core.Settings()
            folder_path = paths[0].parent
            settings.setValue(self.path_id, str(folder_path))
        return paths

    def set_extension_filter(self, extension_dict: dict[str, list[str]]):
        """Set filter based on given dictionary.

        dict must contain "'name': ['.ext1', '.ext2']" as key-value pairs

        Args:
            extension_dict: filter dictionary
        """
        items = [
            f"{k} ({' '.join(f'*{ext}' for ext in v)})" for k, v in extension_dict.items()
        ]
        filter_str = ";;".join(items)
        self.setNameFilter(filter_str)

    def get_directory(self) -> pathlib.Path:
        """Return current directory.

        returns current directory level as a Pathlib object

        Returns:
            Pathlib object
        """
        return pathlib.Path(self.directory().absolutePath())

    def set_directory(self, path: datatypes.PathType):
        """Set start directory."""
        path = os.fspath(path)
        self.setDirectory(path)

    def set_filter(self, *filters: core.dir.FilterStr):
        for item in filters:
            if item not in core.dir.FILTERS:
                raise InvalidParamError(item, core.dir.FILTERS)
        flags = helpers.merge_flags(filters, core.dir.FILTERS)
        self.setFilter(flags)

    def get_filter(self) -> list[core.dir.FilterStr]:
        return core.dir.FILTERS.get_list(self.filter())

path_id = path_id instance-attribute

__init__(path: None | datatypes.PathType = None, mode: AcceptModeStr = 'open', caption: str | None = None, path_id: str | None = None, extension_filter: dict | None = None, file_mode: FileModeStr = 'existing_files', parent: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\filedialog.py
def __init__(
    self,
    path: None | datatypes.PathType = None,
    mode: AcceptModeStr = "open",
    caption: str | None = None,
    path_id: str | None = None,
    extension_filter: dict | None = None,
    file_mode: FileModeStr = "existing_files",
    parent: QtWidgets.QWidget | None = None,
):
    super().__init__(parent=parent)
    self.set_title(caption)
    self.path_id = path_id
    if extension_filter:
        self.set_extension_filter(extension_filter)
    if path_id is not None and path is None:
        settings = core.Settings()
        path = settings.get(path_id, "")
    if path is not None:
        self.set_directory(path)
    self.set_file_mode(file_mode)
    self.set_accept_mode(mode)

choose() -> list[pathlib.Path] | None

Source code in prettyqt\widgets\filedialog.py
def choose(self) -> list[pathlib.Path] | None:
    result = self.main_loop()
    if result != self.DialogCode.Accepted:
        return None
    paths = self.selected_files()
    if self.path_id:
        settings = core.Settings()
        folder_path = paths[0].parent
        settings.setValue(self.path_id, str(folder_path))
    return paths

choose_folder() -> list[pathlib.Path] | None

Source code in prettyqt\widgets\filedialog.py
def choose_folder(self) -> list[pathlib.Path] | None:
    self.set_file_mode("directory")
    return self.choose()

get_accept_mode() -> AcceptModeStr

Return accept mode.

Returns:

Type Description
AcceptModeStr

accept mode

Source code in prettyqt\widgets\filedialog.py
def get_accept_mode(self) -> AcceptModeStr:
    """Return accept mode.

    Returns:
        accept mode
    """
    return ACCEPT_MODE.inverse[self.acceptMode()]

get_directory() -> pathlib.Path

Return current directory.

returns current directory level as a Pathlib object

Returns:

Type Description
pathlib.Path

Pathlib object

Source code in prettyqt\widgets\filedialog.py
def get_directory(self) -> pathlib.Path:
    """Return current directory.

    returns current directory level as a Pathlib object

    Returns:
        Pathlib object
    """
    return pathlib.Path(self.directory().absolutePath())

get_file_mode() -> FileModeStr

Return file mode.

Returns:

Type Description
FileModeStr

file mode

Source code in prettyqt\widgets\filedialog.py
def get_file_mode(self) -> FileModeStr:
    """Return file mode.

    Returns:
        file mode
    """
    return FILE_MODE.inverse[self.fileMode()]

get_filter() -> list[core.dir.FilterStr]

Source code in prettyqt\widgets\filedialog.py
def get_filter(self) -> list[core.dir.FilterStr]:
    return core.dir.FILTERS.get_list(self.filter())

get_label_text(label: LabelStr) -> str

Return label text.

Returns:

Type Description
str

label text

Source code in prettyqt\widgets\filedialog.py
def get_label_text(self, label: LabelStr) -> str:
    """Return label text.

    Returns:
        label text
    """
    return self.labelText(LABEL[label])

get_view_mode() -> ViewModeStr

Return view mode.

Returns:

Type Description
ViewModeStr

view mode

Source code in prettyqt\widgets\filedialog.py
def get_view_mode(self) -> ViewModeStr:
    """Return view mode.

    Returns:
        view mode
    """
    return VIEW_MODE.inverse[self.viewMode()]

open_file() -> list[pathlib.Path] | None

Source code in prettyqt\widgets\filedialog.py
def open_file(self) -> list[pathlib.Path] | None:
    self.set_file_mode("existing_file")
    return self.choose()

selected_file() -> pathlib.Path | None

Source code in prettyqt\widgets\filedialog.py
def selected_file(self) -> pathlib.Path | None:
    selected = self.selectedFiles()
    return pathlib.Path(selected[0]) if selected else None

selected_files() -> list[pathlib.Path]

Source code in prettyqt\widgets\filedialog.py
def selected_files(self) -> list[pathlib.Path]:
    return [pathlib.Path(p) for p in self.selectedFiles()]

set_accept_mode(mode: AcceptModeStr)

Set accept mode.

Parameters:

Name Type Description Default
mode AcceptModeStr

accept mode to use

required

Raises:

Type Description
InvalidParamError

invalid accept mode

Source code in prettyqt\widgets\filedialog.py
def set_accept_mode(self, mode: AcceptModeStr):
    """Set accept mode.

    Args:
        mode: accept mode to use

    Raises:
        InvalidParamError: invalid accept mode
    """
    if mode not in ACCEPT_MODE:
        raise InvalidParamError(mode, ACCEPT_MODE)
    self.setAcceptMode(ACCEPT_MODE[mode])

set_directory(path: datatypes.PathType)

Set start directory.

Source code in prettyqt\widgets\filedialog.py
def set_directory(self, path: datatypes.PathType):
    """Set start directory."""
    path = os.fspath(path)
    self.setDirectory(path)

set_extension_filter(extension_dict: dict[str, list[str]])

Set filter based on given dictionary.

dict must contain "'name': ['.ext1', '.ext2']" as key-value pairs

Parameters:

Name Type Description Default
extension_dict dict[str, list[str]]

filter dictionary

required
Source code in prettyqt\widgets\filedialog.py
def set_extension_filter(self, extension_dict: dict[str, list[str]]):
    """Set filter based on given dictionary.

    dict must contain "'name': ['.ext1', '.ext2']" as key-value pairs

    Args:
        extension_dict: filter dictionary
    """
    items = [
        f"{k} ({' '.join(f'*{ext}' for ext in v)})" for k, v in extension_dict.items()
    ]
    filter_str = ";;".join(items)
    self.setNameFilter(filter_str)

set_file_mode(mode: FileModeStr)

Set the file mode of the dialog.

Parameters:

Name Type Description Default
mode FileModeStr

mode to use

required
Source code in prettyqt\widgets\filedialog.py
def set_file_mode(self, mode: FileModeStr):
    """Set the file mode of the dialog.

    Args:
        mode: mode to use
    """
    self.setFileMode(FILE_MODE[mode])

set_filter(*filters: core.dir.FilterStr)

Source code in prettyqt\widgets\filedialog.py
def set_filter(self, *filters: core.dir.FilterStr):
    for item in filters:
        if item not in core.dir.FILTERS:
            raise InvalidParamError(item, core.dir.FILTERS)
    flags = helpers.merge_flags(filters, core.dir.FILTERS)
    self.setFilter(flags)

set_label_text(label: LabelStr, text: str)

Set the label text for button label.

Parameters:

Name Type Description Default
label LabelStr

button to set text for

required
text str

text to use

required
Source code in prettyqt\widgets\filedialog.py
def set_label_text(self, label: LabelStr, text: str):
    """Set the label text for button label.

    Args:
        label: button to set text for
        text: text to use
    """
    if label not in LABEL:
        raise InvalidParamError(label, LABEL)
    self.setLabelText(LABEL[label], text)

set_view_mode(mode: ViewModeStr)

Set view mode.

Parameters:

Name Type Description Default
mode ViewModeStr

view mode to use

required

Raises:

Type Description
InvalidParamError

invalid view mode

Source code in prettyqt\widgets\filedialog.py
def set_view_mode(self, mode: ViewModeStr):
    """Set view mode.

    Args:
        mode: view mode to use

    Raises:
        InvalidParamError: invalid view mode
    """
    if mode not in VIEW_MODE:
        raise InvalidParamError(mode, VIEW_MODE)
    self.setViewMode(VIEW_MODE[mode])

FileIconProvider

Bases: gui.AbstractFileIconProviderMixin, QtWidgets.QFileIconProvider

Source code in prettyqt\widgets\fileiconprovider.py
class FileIconProvider(gui.AbstractFileIconProviderMixin, QtWidgets.QFileIconProvider):
    def get_icon(
        self,
        typ: gui.abstractfileiconprovider.IconTypeStr
        | QtCore.QFileInfo
        | datatypes.PathType,
    ) -> QtGui.QIcon:
        if isinstance(typ, os.PathLike | QtCore.QFileInfo):
            param = core.FileInfo(typ)
        else:
            param = gui.abstractfileiconprovider.ICON_TYPE[typ]
        return self.icon(param)

get_icon(typ: gui.abstractfileiconprovider.IconTypeStr | QtCore.QFileInfo | datatypes.PathType) -> QtGui.QIcon

Source code in prettyqt\widgets\fileiconprovider.py
def get_icon(
    self,
    typ: gui.abstractfileiconprovider.IconTypeStr
    | QtCore.QFileInfo
    | datatypes.PathType,
) -> QtGui.QIcon:
    if isinstance(typ, os.PathLike | QtCore.QFileInfo):
        param = core.FileInfo(typ)
    else:
        param = gui.abstractfileiconprovider.ICON_TYPE[typ]
    return self.icon(param)

FileSystemModel

Bases: FileSystemModelMixin, QtWidgets.QFileSystemModel

Source code in prettyqt\widgets\filesystemmodel.py
class FileSystemModel(FileSystemModelMixin, QtWidgets.QFileSystemModel):
    pass

FocusFrame

Bases: widgets.WidgetMixin, QtWidgets.QFocusFrame

Source code in prettyqt\widgets\focusframe.py
class FocusFrame(widgets.WidgetMixin, QtWidgets.QFocusFrame):
    pass

FontComboBox

Bases: widgets.ComboBoxMixin, QtWidgets.QFontComboBox

Source code in prettyqt\widgets\fontcombobox.py
class FontComboBox(widgets.ComboBoxMixin, QtWidgets.QFontComboBox):
    value_changed = core.Signal(object)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.currentIndexChanged.connect(self.index_changed)

    def set_font_filters(self, *filters: FontFilterStr):
        """Set font filters.

        Args:
            filters: font filters to use

        Raises:
            InvalidParamError: invalid font filters
        """
        if not filters:
            filters = ("all",)
        for item in filters:
            if item not in FONT_FILTERS:
                raise InvalidParamError(item, FONT_FILTERS)
        flags = helpers.merge_flags(filters, FONT_FILTERS)
        self.setFontFilters(flags)

    def get_font_filters(self) -> list[FontFilterStr]:
        """Return list of font filters.

        Returns:
            font filter list
        """
        return FONT_FILTERS.get_list(self.fontFilters())

    def set_value(self, value: QtGui.QFont):
        self.setCurrentFont(value)

    def get_value(self) -> gui.Font:
        return self.get_current_font()

    def get_current_font(self) -> gui.Font:
        return gui.Font(self.currentFont())

value_changed = core.Signal(object) class-attribute

__init__(*args, **kwargs)

Source code in prettyqt\widgets\fontcombobox.py
def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.currentIndexChanged.connect(self.index_changed)

get_current_font() -> gui.Font

Source code in prettyqt\widgets\fontcombobox.py
def get_current_font(self) -> gui.Font:
    return gui.Font(self.currentFont())

get_font_filters() -> list[FontFilterStr]

Return list of font filters.

Returns:

Type Description
list[FontFilterStr]

font filter list

Source code in prettyqt\widgets\fontcombobox.py
def get_font_filters(self) -> list[FontFilterStr]:
    """Return list of font filters.

    Returns:
        font filter list
    """
    return FONT_FILTERS.get_list(self.fontFilters())

get_value() -> gui.Font

Source code in prettyqt\widgets\fontcombobox.py
def get_value(self) -> gui.Font:
    return self.get_current_font()

set_font_filters(*filters: FontFilterStr)

Set font filters.

Parameters:

Name Type Description Default
filters FontFilterStr

font filters to use

()

Raises:

Type Description
InvalidParamError

invalid font filters

Source code in prettyqt\widgets\fontcombobox.py
def set_font_filters(self, *filters: FontFilterStr):
    """Set font filters.

    Args:
        filters: font filters to use

    Raises:
        InvalidParamError: invalid font filters
    """
    if not filters:
        filters = ("all",)
    for item in filters:
        if item not in FONT_FILTERS:
            raise InvalidParamError(item, FONT_FILTERS)
    flags = helpers.merge_flags(filters, FONT_FILTERS)
    self.setFontFilters(flags)

set_value(value: QtGui.QFont)

Source code in prettyqt\widgets\fontcombobox.py
def set_value(self, value: QtGui.QFont):
    self.setCurrentFont(value)

FontDialog

Bases: widgets.DialogMixin, QtWidgets.QFontDialog

Source code in prettyqt\widgets\fontdialog.py
7
8
9
class FontDialog(widgets.DialogMixin, QtWidgets.QFontDialog):
    def get_current_font(self) -> gui.Font:
        return gui.Font(self.currentFont())

get_current_font() -> gui.Font

Source code in prettyqt\widgets\fontdialog.py
def get_current_font(self) -> gui.Font:
    return gui.Font(self.currentFont())

FormLayout

Bases: widgets.LayoutMixin, QtWidgets.QFormLayout

Source code in prettyqt\widgets\formlayout.py
class FormLayout(widgets.LayoutMixin, QtWidgets.QFormLayout):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.set_size_constraint("maximum")
        self.setVerticalSpacing(8)

    def __setitem__(
        self, index: int | tuple[int, RoleStr], value: str | QtWidgets.QWidget
    ):
        if isinstance(index, tuple):
            row = index[0]
            role = index[1]
        else:
            row = index
            role = "both"
        self.set_widget(value, row, role)

    def __delitem__(self, index: int):
        self.removeRow(index)

    def __iter__(self) -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout]:
        return iter(self[i] for i in range(self.count()) if self[i] is not None)

    def __len__(self) -> int:
        """Needed for PySide2."""
        return self.rowCount()

    def __add__(self, other: QtWidgets.QWidget | QtWidgets.QLayout | tuple):
        self.add(other)
        return self

    # def serialize_fields(self):
    #     widget_list = []
    #     positions = []
    #     for i, item in enumerate(list(self)):
    #         widget_list.append(item)
    #         positions.append(self.get_item_position(i))
    #     return dict(widgets=widget_list, positions=positions)

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    # def __setstate__(self, state):
    #     for item, pos in zip(state["widgets"], state["positions"]):
    #         self.set_widget(item, pos[0], pos[1])

    def set_widget(
        self, widget: str | QtWidgets.QWidget, row: int, role: RoleStr = "both"
    ):
        if isinstance(widget, str):
            widget = widgets.Label(widget)
        self.setWidget(row, ROLE[role], widget)

    def get_widget(
        self, row: int, role: RoleStr = "both"
    ) -> QtWidgets.QLayout | QtWidgets.QWidget:
        item = self.itemAt(row, ROLE[role])
        widget = item.widget()
        if widget is None:
            widget = item.layout()
        return widget

    def get_item_position(self, index: int) -> tuple[int, RoleStr] | None:
        pos = self.getItemPosition(index)  # type: ignore
        return None if pos[0] == -1 else (pos[0], ROLE.inverse[pos[1]])

    def add(self, *items):
        for i in items:
            if isinstance(i, QtWidgets.QWidget | QtWidgets.QLayout):
                self.addRow(i)
            elif isinstance(i, tuple):
                self.addRow(*i)

    def set_row_wrap_policy(self, policy: RowWrapPolicyStr):
        """Set row wrap policy to use.

        Args:
            policy: row wrap policy to use

        Raises:
            InvalidParamError: row wrap policy does not exist
        """
        if policy not in ROW_WRAP_POLICY:
            raise InvalidParamError(policy, ROW_WRAP_POLICY)
        self.setRowWrapPolicy(ROW_WRAP_POLICY[policy])

    def get_row_wrap_policy(self) -> RowWrapPolicyStr:
        """Return current row wrap policy.

        Returns:
            row wrap policy
        """
        return ROW_WRAP_POLICY.inverse[self.rowWrapPolicy()]

    def set_field_growth_policy(self, policy: FieldGrowthPolicyStr):
        """Set field growth policy to use.

        Args:
            policy: field growth policy to use

        Raises:
            InvalidParamError: field growth policy does not exist
        """
        if policy not in FIELD_GROWTH_POLICY:
            raise InvalidParamError(policy, FIELD_GROWTH_POLICY)
        self.setFieldGrowthPolicy(FIELD_GROWTH_POLICY[policy])

    def get_field_growth_policy(self) -> FieldGrowthPolicyStr:
        """Return current field growth policy.

        Returns:
            field growth policy
        """
        return FIELD_GROWTH_POLICY.inverse[self.fieldGrowthPolicy()]

__add__(other: QtWidgets.QWidget | QtWidgets.QLayout | tuple)

Source code in prettyqt\widgets\formlayout.py
def __add__(self, other: QtWidgets.QWidget | QtWidgets.QLayout | tuple):
    self.add(other)
    return self

__delitem__(index: int)

Source code in prettyqt\widgets\formlayout.py
def __delitem__(self, index: int):
    self.removeRow(index)

__init__(*args, **kwargs)

Source code in prettyqt\widgets\formlayout.py
def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.set_size_constraint("maximum")
    self.setVerticalSpacing(8)

__iter__() -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout]

Source code in prettyqt\widgets\formlayout.py
def __iter__(self) -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout]:
    return iter(self[i] for i in range(self.count()) if self[i] is not None)

__len__() -> int

Needed for PySide2.

Source code in prettyqt\widgets\formlayout.py
def __len__(self) -> int:
    """Needed for PySide2."""
    return self.rowCount()

__setitem__(index: int | tuple[int, RoleStr], value: str | QtWidgets.QWidget)

Source code in prettyqt\widgets\formlayout.py
def __setitem__(
    self, index: int | tuple[int, RoleStr], value: str | QtWidgets.QWidget
):
    if isinstance(index, tuple):
        row = index[0]
        role = index[1]
    else:
        row = index
        role = "both"
    self.set_widget(value, row, role)

add(*items)

Source code in prettyqt\widgets\formlayout.py
def add(self, *items):
    for i in items:
        if isinstance(i, QtWidgets.QWidget | QtWidgets.QLayout):
            self.addRow(i)
        elif isinstance(i, tuple):
            self.addRow(*i)

get_field_growth_policy() -> FieldGrowthPolicyStr

Return current field growth policy.

Returns:

Type Description
FieldGrowthPolicyStr

field growth policy

Source code in prettyqt\widgets\formlayout.py
def get_field_growth_policy(self) -> FieldGrowthPolicyStr:
    """Return current field growth policy.

    Returns:
        field growth policy
    """
    return FIELD_GROWTH_POLICY.inverse[self.fieldGrowthPolicy()]

get_item_position(index: int) -> tuple[int, RoleStr] | None

Source code in prettyqt\widgets\formlayout.py
def get_item_position(self, index: int) -> tuple[int, RoleStr] | None:
    pos = self.getItemPosition(index)  # type: ignore
    return None if pos[0] == -1 else (pos[0], ROLE.inverse[pos[1]])

get_row_wrap_policy() -> RowWrapPolicyStr

Return current row wrap policy.

Returns:

Type Description
RowWrapPolicyStr

row wrap policy

Source code in prettyqt\widgets\formlayout.py
def get_row_wrap_policy(self) -> RowWrapPolicyStr:
    """Return current row wrap policy.

    Returns:
        row wrap policy
    """
    return ROW_WRAP_POLICY.inverse[self.rowWrapPolicy()]

get_widget(row: int, role: RoleStr = 'both') -> QtWidgets.QLayout | QtWidgets.QWidget

Source code in prettyqt\widgets\formlayout.py
def get_widget(
    self, row: int, role: RoleStr = "both"
) -> QtWidgets.QLayout | QtWidgets.QWidget:
    item = self.itemAt(row, ROLE[role])
    widget = item.widget()
    if widget is None:
        widget = item.layout()
    return widget

set_field_growth_policy(policy: FieldGrowthPolicyStr)

Set field growth policy to use.

Parameters:

Name Type Description Default
policy FieldGrowthPolicyStr

field growth policy to use

required

Raises:

Type Description
InvalidParamError

field growth policy does not exist

Source code in prettyqt\widgets\formlayout.py
def set_field_growth_policy(self, policy: FieldGrowthPolicyStr):
    """Set field growth policy to use.

    Args:
        policy: field growth policy to use

    Raises:
        InvalidParamError: field growth policy does not exist
    """
    if policy not in FIELD_GROWTH_POLICY:
        raise InvalidParamError(policy, FIELD_GROWTH_POLICY)
    self.setFieldGrowthPolicy(FIELD_GROWTH_POLICY[policy])

set_row_wrap_policy(policy: RowWrapPolicyStr)

Set row wrap policy to use.

Parameters:

Name Type Description Default
policy RowWrapPolicyStr

row wrap policy to use

required

Raises:

Type Description
InvalidParamError

row wrap policy does not exist

Source code in prettyqt\widgets\formlayout.py
def set_row_wrap_policy(self, policy: RowWrapPolicyStr):
    """Set row wrap policy to use.

    Args:
        policy: row wrap policy to use

    Raises:
        InvalidParamError: row wrap policy does not exist
    """
    if policy not in ROW_WRAP_POLICY:
        raise InvalidParamError(policy, ROW_WRAP_POLICY)
    self.setRowWrapPolicy(ROW_WRAP_POLICY[policy])

set_widget(widget: str | QtWidgets.QWidget, row: int, role: RoleStr = 'both')

Source code in prettyqt\widgets\formlayout.py
def set_widget(
    self, widget: str | QtWidgets.QWidget, row: int, role: RoleStr = "both"
):
    if isinstance(widget, str):
        widget = widgets.Label(widget)
    self.setWidget(row, ROLE[role], widget)

Frame

Bases: FrameMixin, QtWidgets.QFrame

Source code in prettyqt\widgets\frame.py
class Frame(FrameMixin, QtWidgets.QFrame):
    pass

FrameMixin

Bases: widgets.WidgetMixin

Source code in prettyqt\widgets\frame.py
class FrameMixin(widgets.WidgetMixin):
    def set_frame_shadow(self, style: ShadowStr):
        """Set frame shadow.

        Args:
            style: frame style to use

        Raises:
            InvalidParamError: style does not exist
        """
        if style is None:
            return
        if style not in SHADOW:
            raise InvalidParamError(style, SHADOW)
        self.setFrameShadow(SHADOW[style])

    def get_frame_shadow(self) -> ShadowStr | None:
        """Return current frame shadow.

        Returns:
            frame style
        """
        if (frame_shadow := self.frameShadow()) == 0:
            return None
        return SHADOW.inverse[frame_shadow]

    def set_frame_shape(self, shape: FrameShapeStr):
        """Set frame shape.

        Args:
            shape: frame shape to use

        Raises:
            InvalidParamError: shape does not exist
        """
        if shape not in FRAME_SHAPE:
            raise InvalidParamError(shape, FRAME_SHAPE)
        self.setFrameShape(FRAME_SHAPE[shape])

    def get_frame_shape(self) -> FrameShapeStr:
        """Return current frame shape.

        Returns:
            frame shape
        """
        return FRAME_SHAPE.inverse[self.frameShape()]

get_frame_shadow() -> ShadowStr | None

Return current frame shadow.

Returns:

Type Description
ShadowStr | None

frame style

Source code in prettyqt\widgets\frame.py
def get_frame_shadow(self) -> ShadowStr | None:
    """Return current frame shadow.

    Returns:
        frame style
    """
    if (frame_shadow := self.frameShadow()) == 0:
        return None
    return SHADOW.inverse[frame_shadow]

get_frame_shape() -> FrameShapeStr

Return current frame shape.

Returns:

Type Description
FrameShapeStr

frame shape

Source code in prettyqt\widgets\frame.py
def get_frame_shape(self) -> FrameShapeStr:
    """Return current frame shape.

    Returns:
        frame shape
    """
    return FRAME_SHAPE.inverse[self.frameShape()]

set_frame_shadow(style: ShadowStr)

Set frame shadow.

Parameters:

Name Type Description Default
style ShadowStr

frame style to use

required

Raises:

Type Description
InvalidParamError

style does not exist

Source code in prettyqt\widgets\frame.py
def set_frame_shadow(self, style: ShadowStr):
    """Set frame shadow.

    Args:
        style: frame style to use

    Raises:
        InvalidParamError: style does not exist
    """
    if style is None:
        return
    if style not in SHADOW:
        raise InvalidParamError(style, SHADOW)
    self.setFrameShadow(SHADOW[style])

set_frame_shape(shape: FrameShapeStr)

Set frame shape.

Parameters:

Name Type Description Default
shape FrameShapeStr

frame shape to use

required

Raises:

Type Description
InvalidParamError

shape does not exist

Source code in prettyqt\widgets\frame.py
def set_frame_shape(self, shape: FrameShapeStr):
    """Set frame shape.

    Args:
        shape: frame shape to use

    Raises:
        InvalidParamError: shape does not exist
    """
    if shape not in FRAME_SHAPE:
        raise InvalidParamError(shape, FRAME_SHAPE)
    self.setFrameShape(FRAME_SHAPE[shape])

Gesture

Bases: GestureMixin, QtWidgets.QGesture

Source code in prettyqt\widgets\gesture.py
class Gesture(GestureMixin, QtWidgets.QGesture):
    pass

GestureMixin

Bases: core.ObjectMixin

Source code in prettyqt\widgets\gesture.py
class GestureMixin(core.ObjectMixin):
    def get_state(self) -> constants.GestureStateStr:
        """Return current state.

        Returns:
            state
        """
        return constants.GESTURE_STATE.inverse[self.state()]

    def get_gesture_type(self) -> constants.GestureTypeStr:
        """Return current gesture type.

        Returns:
            gesture type
        """
        return constants.GESTURE_TYPE.inverse[self.gestureType()]

    def get_hot_spot(self) -> core.PointF:
        return core.PointF(self.hotSpot())

    def set_gesture_cancel_policy(self, policy: GestureCancelPolicyStr):
        """Set gesture cancel policy.

        Args:
            policy: gesture cancel policy to use

        Raises:
            InvalidParamError: gesture cancel policy does not exist
        """
        if policy not in GESTURE_CANCEL_POLICY:
            raise InvalidParamError(policy, GESTURE_CANCEL_POLICY)
        self.setGestureCancelPolicy(GESTURE_CANCEL_POLICY[policy])

    def get_gesture_cancel_policy(self) -> GestureCancelPolicyStr:
        """Return current gesture cancel policy.

        Returns:
            gesture cancel policy
        """
        return GESTURE_CANCEL_POLICY.inverse[self.gestureCancelPolicy()]

get_gesture_cancel_policy() -> GestureCancelPolicyStr

Return current gesture cancel policy.

Returns:

Type Description
GestureCancelPolicyStr

gesture cancel policy

Source code in prettyqt\widgets\gesture.py
def get_gesture_cancel_policy(self) -> GestureCancelPolicyStr:
    """Return current gesture cancel policy.

    Returns:
        gesture cancel policy
    """
    return GESTURE_CANCEL_POLICY.inverse[self.gestureCancelPolicy()]

get_gesture_type() -> constants.GestureTypeStr

Return current gesture type.

Returns:

Type Description
constants.GestureTypeStr

gesture type

Source code in prettyqt\widgets\gesture.py
def get_gesture_type(self) -> constants.GestureTypeStr:
    """Return current gesture type.

    Returns:
        gesture type
    """
    return constants.GESTURE_TYPE.inverse[self.gestureType()]

get_hot_spot() -> core.PointF

Source code in prettyqt\widgets\gesture.py
def get_hot_spot(self) -> core.PointF:
    return core.PointF(self.hotSpot())

get_state() -> constants.GestureStateStr

Return current state.

Returns:

Type Description
constants.GestureStateStr

state

Source code in prettyqt\widgets\gesture.py
def get_state(self) -> constants.GestureStateStr:
    """Return current state.

    Returns:
        state
    """
    return constants.GESTURE_STATE.inverse[self.state()]

set_gesture_cancel_policy(policy: GestureCancelPolicyStr)

Set gesture cancel policy.

Parameters:

Name Type Description Default
policy GestureCancelPolicyStr

gesture cancel policy to use

required

Raises:

Type Description
InvalidParamError

gesture cancel policy does not exist

Source code in prettyqt\widgets\gesture.py
def set_gesture_cancel_policy(self, policy: GestureCancelPolicyStr):
    """Set gesture cancel policy.

    Args:
        policy: gesture cancel policy to use

    Raises:
        InvalidParamError: gesture cancel policy does not exist
    """
    if policy not in GESTURE_CANCEL_POLICY:
        raise InvalidParamError(policy, GESTURE_CANCEL_POLICY)
    self.setGestureCancelPolicy(GESTURE_CANCEL_POLICY[policy])

GraphicsAnchorLayout

Bases: widgets.GraphicsLayoutMixin, QtWidgets.QGraphicsAnchorLayout

Source code in prettyqt\widgets\graphicsanchorlayout.py
class GraphicsAnchorLayout(widgets.GraphicsLayoutMixin, QtWidgets.QGraphicsAnchorLayout):
    def add_anchor(
        self,
        first_item: QtWidgets.QGraphicsLayoutItem,
        first_edge: constants.AnchorPointStr,
        second_item: QtWidgets.QGraphicsLayoutItem,
        second_edge: constants.AnchorPointStr,
    ) -> QtWidgets.QGraphicsAnchor:
        return self.addAnchor(
            first_item,
            constants.ANCHOR_POINT[first_edge],
            second_item,
            constants.ANCHOR_POINT[second_edge],
        )

    def get_anchor(
        self,
        first_item: QtWidgets.QGraphicsLayoutItem,
        first_edge: constants.AnchorPointStr,
        second_item: QtWidgets.QGraphicsLayoutItem,
        second_edge: constants.AnchorPointStr,
    ) -> QtWidgets.QGraphicsAnchor:
        return self.anchor(
            first_item,
            constants.ANCHOR_POINT[first_edge],
            second_item,
            constants.ANCHOR_POINT[second_edge],
        )

    def add_anchors(
        self,
        first_item: QtWidgets.QGraphicsLayoutItem,
        second_item: QtWidgets.QGraphicsLayoutItem,
        orientation: constants.OrientationStr,
    ):
        if orientation not in constants.ORIENTATION:
            raise InvalidParamError(orientation, constants.ORIENTATION)
        self.addAnchors(
            first_item, second_item, constants.ORIENTATION[orientation]  # type: ignore
        )

    def add_corner_anchors(
        self,
        first_item: QtWidgets.QGraphicsLayoutItem,
        first_corner: constants.CornerStr,
        second_item: QtWidgets.QGraphicsLayoutItem,
        second_corner: constants.CornerStr,
    ):
        self.addCornerAnchors(
            first_item,
            constants.CORNER[first_corner],
            second_item,
            constants.CORNER[second_corner],
        )

add_anchor(first_item: QtWidgets.QGraphicsLayoutItem, first_edge: constants.AnchorPointStr, second_item: QtWidgets.QGraphicsLayoutItem, second_edge: constants.AnchorPointStr) -> QtWidgets.QGraphicsAnchor

Source code in prettyqt\widgets\graphicsanchorlayout.py
def add_anchor(
    self,
    first_item: QtWidgets.QGraphicsLayoutItem,
    first_edge: constants.AnchorPointStr,
    second_item: QtWidgets.QGraphicsLayoutItem,
    second_edge: constants.AnchorPointStr,
) -> QtWidgets.QGraphicsAnchor:
    return self.addAnchor(
        first_item,
        constants.ANCHOR_POINT[first_edge],
        second_item,
        constants.ANCHOR_POINT[second_edge],
    )

add_anchors(first_item: QtWidgets.QGraphicsLayoutItem, second_item: QtWidgets.QGraphicsLayoutItem, orientation: constants.OrientationStr)

Source code in prettyqt\widgets\graphicsanchorlayout.py
def add_anchors(
    self,
    first_item: QtWidgets.QGraphicsLayoutItem,
    second_item: QtWidgets.QGraphicsLayoutItem,
    orientation: constants.OrientationStr,
):
    if orientation not in constants.ORIENTATION:
        raise InvalidParamError(orientation, constants.ORIENTATION)
    self.addAnchors(
        first_item, second_item, constants.ORIENTATION[orientation]  # type: ignore
    )

add_corner_anchors(first_item: QtWidgets.QGraphicsLayoutItem, first_corner: constants.CornerStr, second_item: QtWidgets.QGraphicsLayoutItem, second_corner: constants.CornerStr)

Source code in prettyqt\widgets\graphicsanchorlayout.py
def add_corner_anchors(
    self,
    first_item: QtWidgets.QGraphicsLayoutItem,
    first_corner: constants.CornerStr,
    second_item: QtWidgets.QGraphicsLayoutItem,
    second_corner: constants.CornerStr,
):
    self.addCornerAnchors(
        first_item,
        constants.CORNER[first_corner],
        second_item,
        constants.CORNER[second_corner],
    )

get_anchor(first_item: QtWidgets.QGraphicsLayoutItem, first_edge: constants.AnchorPointStr, second_item: QtWidgets.QGraphicsLayoutItem, second_edge: constants.AnchorPointStr) -> QtWidgets.QGraphicsAnchor

Source code in prettyqt\widgets\graphicsanchorlayout.py
def get_anchor(
    self,
    first_item: QtWidgets.QGraphicsLayoutItem,
    first_edge: constants.AnchorPointStr,
    second_item: QtWidgets.QGraphicsLayoutItem,
    second_edge: constants.AnchorPointStr,
) -> QtWidgets.QGraphicsAnchor:
    return self.anchor(
        first_item,
        constants.ANCHOR_POINT[first_edge],
        second_item,
        constants.ANCHOR_POINT[second_edge],
    )

GraphicsBlurEffect

Bases: widgets.GraphicsEffectMixin, QtWidgets.QGraphicsBlurEffect

Source code in prettyqt\widgets\graphicsblureffect.py
class GraphicsBlurEffect(widgets.GraphicsEffectMixin, QtWidgets.QGraphicsBlurEffect):
    def set_blur_hints(self, *hints: BlurHintStr):
        for item in hints:
            if item not in BLUR_HINTS:
                raise InvalidParamError(item, BLUR_HINTS)
        if hints:
            flags = helpers.merge_flags(hints, BLUR_HINTS)
        else:
            flags = QtWidgets.QGraphicsBlurEffect.BlurHint(0)  # type: ignore
        self.setBlurHints(flags)

    def get_blur_hints(self) -> list[BlurHintStr]:
        return BLUR_HINTS.get_list(self.blurHints())

get_blur_hints() -> list[BlurHintStr]

Source code in prettyqt\widgets\graphicsblureffect.py
def get_blur_hints(self) -> list[BlurHintStr]:
    return BLUR_HINTS.get_list(self.blurHints())

set_blur_hints(*hints: BlurHintStr)

Source code in prettyqt\widgets\graphicsblureffect.py
def set_blur_hints(self, *hints: BlurHintStr):
    for item in hints:
        if item not in BLUR_HINTS:
            raise InvalidParamError(item, BLUR_HINTS)
    if hints:
        flags = helpers.merge_flags(hints, BLUR_HINTS)
    else:
        flags = QtWidgets.QGraphicsBlurEffect.BlurHint(0)  # type: ignore
    self.setBlurHints(flags)

GraphicsColorizeEffect

Bases: widgets.GraphicsEffectMixin, QtWidgets.QGraphicsColorizeEffect

Source code in prettyqt\widgets\graphicscolorizeeffect.py
class GraphicsColorizeEffect(
    widgets.GraphicsEffectMixin, QtWidgets.QGraphicsColorizeEffect
):
    def serialize_fields(self):
        return dict(strength=self.strength(), color=gui.Color(self.color()))

    def __setstate__(self, state):
        super().__setstate__(state)
        self.setStrength(state["strength"])
        self.setColor(state["color"])

__setstate__(state)

Source code in prettyqt\widgets\graphicscolorizeeffect.py
def __setstate__(self, state):
    super().__setstate__(state)
    self.setStrength(state["strength"])
    self.setColor(state["color"])

serialize_fields()

Source code in prettyqt\widgets\graphicscolorizeeffect.py
def serialize_fields(self):
    return dict(strength=self.strength(), color=gui.Color(self.color()))

GraphicsDropShadowEffect

Bases: widgets.GraphicsEffectMixin, QtWidgets.QGraphicsDropShadowEffect

Source code in prettyqt\widgets\graphicsdropshadoweffect.py
class GraphicsDropShadowEffect(
    widgets.GraphicsEffectMixin, QtWidgets.QGraphicsDropShadowEffect
):
    def serialize_fields(self):
        offset = self.offset()
        return dict(
            blur_radius=self.blurRadius(),
            color=gui.Color(self.color()),
            offset=(offset.x(), offset.y()),
        )

serialize_fields()

Source code in prettyqt\widgets\graphicsdropshadoweffect.py
def serialize_fields(self):
    offset = self.offset()
    return dict(
        blur_radius=self.blurRadius(),
        color=gui.Color(self.color()),
        offset=(offset.x(), offset.y()),
    )

GraphicsEffect

Bases: GraphicsEffectMixin, QtWidgets.QGraphicsEffect

Source code in prettyqt\widgets\graphicseffect.py
class GraphicsEffect(GraphicsEffectMixin, QtWidgets.QGraphicsEffect):
    pass

GraphicsEffectMixin

Bases: core.ObjectMixin

Source code in prettyqt\widgets\graphicseffect.py
class GraphicsEffectMixin(core.ObjectMixin):
    pass

GraphicsEllipseItem

Bases: widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsEllipseItem

Source code in prettyqt\widgets\graphicsellipseitem.py
class GraphicsEllipseItem(
    widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsEllipseItem
):
    def __repr__(self):
        return get_repr(self, self.get_rect())

    def serialize_fields(self):
        return dict(
            rect=self.get_rect(),
            span_angle=self.spanAngle(),
            start_angle=self.startAngle(),
        )

    def get_rect(self) -> core.RectF:
        return core.RectF(self.rect())

__repr__()

Source code in prettyqt\widgets\graphicsellipseitem.py
def __repr__(self):
    return get_repr(self, self.get_rect())

get_rect() -> core.RectF

Source code in prettyqt\widgets\graphicsellipseitem.py
def get_rect(self) -> core.RectF:
    return core.RectF(self.rect())

serialize_fields()

Source code in prettyqt\widgets\graphicsellipseitem.py
def serialize_fields(self):
    return dict(
        rect=self.get_rect(),
        span_angle=self.spanAngle(),
        start_angle=self.startAngle(),
    )

GraphicsGridLayout

Bases: widgets.GraphicsLayoutMixin, QtWidgets.QGraphicsGridLayout

Source code in prettyqt\widgets\graphicsgridlayout.py
class GraphicsGridLayout(widgets.GraphicsLayoutMixin, QtWidgets.QGraphicsGridLayout):
    def __getitem__(
        self, idx: tuple[int, int] | int
    ) -> QtWidgets.QGraphicsLayoutItem | None:
        return self.itemAt(*idx) if isinstance(idx, tuple) else self.itemAt(idx)

    def __setitem__(
        self,
        idx: tuple[int | slice, int | slice],
        value: QtWidgets.QGraphicsLayoutItem,
    ):
        row, col = idx
        rowspan = row.stop - row.start + 1 if isinstance(row, slice) else 1
        colspan = col.stop - col.start + 1 if isinstance(col, slice) else 1
        rowstart = row.start if isinstance(row, slice) else row
        colstart = col.start if isinstance(col, slice) else col
        self.add(value, rowstart, colstart, rowspan, colspan)

    def serialize_fields(self):
        items = []
        positions = []
        for row in range(self.rowCount()):
            for col in range(self.columnCount()):
                item = self.itemAt(row, col)
                if item is not None:
                    items.append(item)
                    positions.append((row, col))
        return dict(widgets=items, positions=positions)

    def __reduce__(self):
        return type(self), (), self.__getstate__()

    def __setstate__(self, state):
        for item, pos in zip(state["widgets"], state["positions"]):
            x, y, w, h = pos
            self[x : x + w - 1, y : y + h - 1] = item

    def __iter__(self) -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout]:
        return iter(self[i] for i in range(self.count()) if self[i] is not None)

    def __add__(
        self,
        other: (Iterable[QtWidgets.QGraphicsLayoutItem] | QtWidgets.QGraphicsLayoutItem),
    ):
        if isinstance(other, Iterable):
            for i, control in enumerate(other):
                self[self.rowCount(), i] = control
        else:
            self[self.rowCount(), 0 : self.columnCount() - 1] = other
        return self

    def add(
        self,
        item: QtWidgets.QGraphicsLayoutItem,
        rowstart: int,
        colstart: int,
        rowspan: int = 1,
        colspan: int = 1,
    ):
        self.addItem(item, rowstart, colstart, rowspan, colspan)

    def append(self, item: QtWidgets.QGraphicsLayoutItem):
        self[self.rowCount(), 0 : self.columnCount() - 1] = item

    def set_column_alignment(self, column: int, alignment: constants.AlignmentStr):
        if alignment not in constants.ALIGNMENTS:
            raise InvalidParamError(alignment, constants.ALIGNMENTS)
        self.setColumnAlignment(column, constants.ALIGNMENTS[alignment])

    def set_row_alignment(self, row: int, alignment: constants.AlignmentStr):
        if alignment not in constants.ALIGNMENTS:
            raise InvalidParamError(alignment, constants.ALIGNMENTS)
        self.setRowAlignment(row, constants.ALIGNMENTS[alignment])

__add__(other: Iterable[QtWidgets.QGraphicsLayoutItem] | QtWidgets.QGraphicsLayoutItem)

Source code in prettyqt\widgets\graphicsgridlayout.py
def __add__(
    self,
    other: (Iterable[QtWidgets.QGraphicsLayoutItem] | QtWidgets.QGraphicsLayoutItem),
):
    if isinstance(other, Iterable):
        for i, control in enumerate(other):
            self[self.rowCount(), i] = control
    else:
        self[self.rowCount(), 0 : self.columnCount() - 1] = other
    return self

__getitem__(idx: tuple[int, int] | int) -> QtWidgets.QGraphicsLayoutItem | None

Source code in prettyqt\widgets\graphicsgridlayout.py
def __getitem__(
    self, idx: tuple[int, int] | int
) -> QtWidgets.QGraphicsLayoutItem | None:
    return self.itemAt(*idx) if isinstance(idx, tuple) else self.itemAt(idx)

__iter__() -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout]

Source code in prettyqt\widgets\graphicsgridlayout.py
def __iter__(self) -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout]:
    return iter(self[i] for i in range(self.count()) if self[i] is not None)

__reduce__()

Source code in prettyqt\widgets\graphicsgridlayout.py
def __reduce__(self):
    return type(self), (), self.__getstate__()

__setitem__(idx: tuple[int | slice, int | slice], value: QtWidgets.QGraphicsLayoutItem)

Source code in prettyqt\widgets\graphicsgridlayout.py
def __setitem__(
    self,
    idx: tuple[int | slice, int | slice],
    value: QtWidgets.QGraphicsLayoutItem,
):
    row, col = idx
    rowspan = row.stop - row.start + 1 if isinstance(row, slice) else 1
    colspan = col.stop - col.start + 1 if isinstance(col, slice) else 1
    rowstart = row.start if isinstance(row, slice) else row
    colstart = col.start if isinstance(col, slice) else col
    self.add(value, rowstart, colstart, rowspan, colspan)

__setstate__(state)

Source code in prettyqt\widgets\graphicsgridlayout.py
def __setstate__(self, state):
    for item, pos in zip(state["widgets"], state["positions"]):
        x, y, w, h = pos
        self[x : x + w - 1, y : y + h - 1] = item

add(item: QtWidgets.QGraphicsLayoutItem, rowstart: int, colstart: int, rowspan: int = 1, colspan: int = 1)

Source code in prettyqt\widgets\graphicsgridlayout.py
def add(
    self,
    item: QtWidgets.QGraphicsLayoutItem,
    rowstart: int,
    colstart: int,
    rowspan: int = 1,
    colspan: int = 1,
):
    self.addItem(item, rowstart, colstart, rowspan, colspan)

append(item: QtWidgets.QGraphicsLayoutItem)

Source code in prettyqt\widgets\graphicsgridlayout.py
def append(self, item: QtWidgets.QGraphicsLayoutItem):
    self[self.rowCount(), 0 : self.columnCount() - 1] = item

serialize_fields()

Source code in prettyqt\widgets\graphicsgridlayout.py
def serialize_fields(self):
    items = []
    positions = []
    for row in range(self.rowCount()):
        for col in range(self.columnCount()):
            item = self.itemAt(row, col)
            if item is not None:
                items.append(item)
                positions.append((row, col))
    return dict(widgets=items, positions=positions)

set_column_alignment(column: int, alignment: constants.AlignmentStr)

Source code in prettyqt\widgets\graphicsgridlayout.py
def set_column_alignment(self, column: int, alignment: constants.AlignmentStr):
    if alignment not in constants.ALIGNMENTS:
        raise InvalidParamError(alignment, constants.ALIGNMENTS)
    self.setColumnAlignment(column, constants.ALIGNMENTS[alignment])

set_row_alignment(row: int, alignment: constants.AlignmentStr)

Source code in prettyqt\widgets\graphicsgridlayout.py
def set_row_alignment(self, row: int, alignment: constants.AlignmentStr):
    if alignment not in constants.ALIGNMENTS:
        raise InvalidParamError(alignment, constants.ALIGNMENTS)
    self.setRowAlignment(row, constants.ALIGNMENTS[alignment])

GraphicsItem

Bases: GraphicsItemMixin, QtWidgets.QGraphicsItem

Source code in prettyqt\widgets\graphicsitem.py
class GraphicsItem(GraphicsItemMixin, QtWidgets.QGraphicsItem):
    pass

GraphicsItemGroup

Bases: widgets.GraphicsItemMixin, QtWidgets.QGraphicsItemGroup

Source code in prettyqt\widgets\graphicsitemgroup.py
class GraphicsItemGroup(widgets.GraphicsItemMixin, QtWidgets.QGraphicsItemGroup):
    pass

GraphicsItemMixin

Source code in prettyqt\widgets\graphicsitem.py
class GraphicsItemMixin:
    def __repr__(self):
        return get_repr(self)

    def __contains__(self, value: QtCore.QPointF) -> bool:
        return self.contains(value)

    def __getitem__(self, key: int):
        return self.data(key)

    def __setitem__(self, key: int, value):
        self.setData(key, value)

    def set_focus(self, reason: constants.FocusReasonStr = "other"):
        if reason not in constants.FOCUS_REASONS:
            raise InvalidParamError(reason, constants.FOCUS_REASONS)
        self.setFocus(constants.FOCUS_REASONS[reason])

    def colliding_items(
        self, mode: constants.ItemSelectionModeStr = "intersects_shape"
    ) -> list[QtWidgets.QGraphicsItem]:
        if mode not in constants.ITEM_SELECTION_MODE:
            raise InvalidParamError(mode, constants.ITEM_SELECTION_MODE)
        return self.collidingItems(constants.ITEM_SELECTION_MODE[mode])

    def collides_with(
        self,
        item: QtGui.QPainterPath | QtWidgets.QGraphicsItem,
        mode: constants.ItemSelectionModeStr = "intersects_shape",
    ) -> bool:
        if mode not in constants.ITEM_SELECTION_MODE:
            raise InvalidParamError(mode, constants.ITEM_SELECTION_MODE)
        if isinstance(item, QtGui.QPainterPath):
            return self.collidesWithPath(item, constants.ITEM_SELECTION_MODE[mode])
        else:
            return self.collidesWithItem(item, constants.ITEM_SELECTION_MODE[mode])

    def set_panel_modality(self, modality: PanelModalityStr) -> None:
        """Set panel modality.

        Args:
            modality: panel modality

        Raises:
            InvalidParamError: panel modality does not exist
        """
        if modality not in PANEL_MODALITY:
            raise InvalidParamError(modality, PANEL_MODALITY)
        self.setPanelModality(PANEL_MODALITY[modality])

    def get_panel_modality(self) -> PanelModalityStr:
        """Get the current modality modes as a string.

        Returns:
            panel modality
        """
        return PANEL_MODALITY.inverse[self.panelModality()]

    def set_cache_mode(self, mode: CacheModeStr) -> None:
        """Set cache mode.

        Args:
            mode: cache mode

        Raises:
            InvalidParamError: cache mode does not exist
        """
        if mode not in CACHE_MODE:
            raise InvalidParamError(mode, CACHE_MODE)
        self.setCacheMode(CACHE_MODE[mode])

    def get_cache_mode(self) -> CacheModeStr:
        """Get the current mode modes as a string.

        Returns:
            cache mode
        """
        return CACHE_MODE.inverse[self.cacheMode()]

    def get_shape(self) -> gui.PainterPath:
        return gui.PainterPath(self.shape())

    def set_scale(self, scale: tuple[float, float] | float):
        if isinstance(scale, float):
            self.setScale(scale)
        else:
            self.setTransform(gui.Transform.fromScale(scale[0], scale[1]), True)

    def set_transform(self, transform: datatypes.TransformType, combine: bool = False):
        if isinstance(transform, tuple):
            transform = gui.Transform(*transform)
        self.setTransform(transform, combine)

__contains__(value: QtCore.QPointF) -> bool

Source code in prettyqt\widgets\graphicsitem.py
def __contains__(self, value: QtCore.QPointF) -> bool:
    return self.contains(value)

__getitem__(key: int)

Source code in prettyqt\widgets\graphicsitem.py
def __getitem__(self, key: int):
    return self.data(key)

__repr__()

Source code in prettyqt\widgets\graphicsitem.py
def __repr__(self):
    return get_repr(self)

__setitem__(key: int, value)

Source code in prettyqt\widgets\graphicsitem.py
def __setitem__(self, key: int, value):
    self.setData(key, value)

collides_with(item: QtGui.QPainterPath | QtWidgets.QGraphicsItem, mode: constants.ItemSelectionModeStr = 'intersects_shape') -> bool

Source code in prettyqt\widgets\graphicsitem.py
def collides_with(
    self,
    item: QtGui.QPainterPath | QtWidgets.QGraphicsItem,
    mode: constants.ItemSelectionModeStr = "intersects_shape",
) -> bool:
    if mode not in constants.ITEM_SELECTION_MODE:
        raise InvalidParamError(mode, constants.ITEM_SELECTION_MODE)
    if isinstance(item, QtGui.QPainterPath):
        return self.collidesWithPath(item, constants.ITEM_SELECTION_MODE[mode])
    else:
        return self.collidesWithItem(item, constants.ITEM_SELECTION_MODE[mode])

colliding_items(mode: constants.ItemSelectionModeStr = 'intersects_shape') -> list[QtWidgets.QGraphicsItem]

Source code in prettyqt\widgets\graphicsitem.py
def colliding_items(
    self, mode: constants.ItemSelectionModeStr = "intersects_shape"
) -> list[QtWidgets.QGraphicsItem]:
    if mode not in constants.ITEM_SELECTION_MODE:
        raise InvalidParamError(mode, constants.ITEM_SELECTION_MODE)
    return self.collidingItems(constants.ITEM_SELECTION_MODE[mode])

get_cache_mode() -> CacheModeStr

Get the current mode modes as a string.

Returns:

Type Description
CacheModeStr

cache mode

Source code in prettyqt\widgets\graphicsitem.py
def get_cache_mode(self) -> CacheModeStr:
    """Get the current mode modes as a string.

    Returns:
        cache mode
    """
    return CACHE_MODE.inverse[self.cacheMode()]

get_panel_modality() -> PanelModalityStr

Get the current modality modes as a string.

Returns:

Type Description
PanelModalityStr

panel modality

Source code in prettyqt\widgets\graphicsitem.py
def get_panel_modality(self) -> PanelModalityStr:
    """Get the current modality modes as a string.

    Returns:
        panel modality
    """
    return PANEL_MODALITY.inverse[self.panelModality()]

get_shape() -> gui.PainterPath

Source code in prettyqt\widgets\graphicsitem.py
def get_shape(self) -> gui.PainterPath:
    return gui.PainterPath(self.shape())

set_cache_mode(mode: CacheModeStr) -> None

Set cache mode.

Parameters:

Name Type Description Default
mode CacheModeStr

cache mode

required

Raises:

Type Description
InvalidParamError

cache mode does not exist

Source code in prettyqt\widgets\graphicsitem.py
def set_cache_mode(self, mode: CacheModeStr) -> None:
    """Set cache mode.

    Args:
        mode: cache mode

    Raises:
        InvalidParamError: cache mode does not exist
    """
    if mode not in CACHE_MODE:
        raise InvalidParamError(mode, CACHE_MODE)
    self.setCacheMode(CACHE_MODE[mode])

set_focus(reason: constants.FocusReasonStr = 'other')

Source code in prettyqt\widgets\graphicsitem.py
def set_focus(self, reason: constants.FocusReasonStr = "other"):
    if reason not in constants.FOCUS_REASONS:
        raise InvalidParamError(reason, constants.FOCUS_REASONS)
    self.setFocus(constants.FOCUS_REASONS[reason])

set_panel_modality(modality: PanelModalityStr) -> None

Set panel modality.

Parameters:

Name Type Description Default
modality PanelModalityStr

panel modality

required

Raises:

Type Description
InvalidParamError

panel modality does not exist

Source code in prettyqt\widgets\graphicsitem.py
def set_panel_modality(self, modality: PanelModalityStr) -> None:
    """Set panel modality.

    Args:
        modality: panel modality

    Raises:
        InvalidParamError: panel modality does not exist
    """
    if modality not in PANEL_MODALITY:
        raise InvalidParamError(modality, PANEL_MODALITY)
    self.setPanelModality(PANEL_MODALITY[modality])

set_scale(scale: tuple[float, float] | float)

Source code in prettyqt\widgets\graphicsitem.py
def set_scale(self, scale: tuple[float, float] | float):
    if isinstance(scale, float):
        self.setScale(scale)
    else:
        self.setTransform(gui.Transform.fromScale(scale[0], scale[1]), True)

set_transform(transform: datatypes.TransformType, combine: bool = False)

Source code in prettyqt\widgets\graphicsitem.py
def set_transform(self, transform: datatypes.TransformType, combine: bool = False):
    if isinstance(transform, tuple):
        transform = gui.Transform(*transform)
    self.setTransform(transform, combine)

GraphicsLayout

Bases: GraphicsLayoutMixin, QtWidgets.QGraphicsLayout

Source code in prettyqt\widgets\graphicslayout.py
class GraphicsLayout(GraphicsLayoutMixin, QtWidgets.QGraphicsLayout):
    pass

GraphicsLayoutItem

Bases: GraphicsLayoutItemMixin, QtWidgets.QGraphicsLayoutItem

Source code in prettyqt\widgets\graphicslayoutitem.py
class GraphicsLayoutItem(GraphicsLayoutItemMixin, QtWidgets.QGraphicsLayoutItem):
    pass

GraphicsLayoutItemMixin

Source code in prettyqt\widgets\graphicslayoutitem.py
class GraphicsLayoutItemMixin:
    def __repr__(self):
        return get_repr(self)

    def __bool__(self):
        return not self.isEmpty()

    @functools.singledispatchmethod
    def set_size_policy(
        self,
        horizontal: widgets.sizepolicy.SizePolicyStr,
        vertical: widgets.sizepolicy.SizePolicyStr,
        control_type: widgets.sizepolicy.ControlTypeStr = "default",
    ):
        """Set the size policy.

        Args:
            horizontal: horizontal size policy
            vertical: vertical size policy
            control_type: control type associated with the widget
        """
        h_policy = widgets.sizepolicy.SIZE_POLICY[horizontal]
        v_policy = widgets.sizepolicy.SIZE_POLICY[vertical]
        c = widgets.sizepolicy.CONTROL_TYPE[control_type]
        self.setSizePolicy(h_policy, v_policy, c)

    @set_size_policy.register
    def _(self, policy: QtWidgets.QSizePolicy):
        self.setSizePolicy(policy)

    def get_size_policy(self) -> widgets.SizePolicy:
        qpol = self.sizePolicy()
        return widgets.SizePolicy.clone(qpol)

_(policy: QtWidgets.QSizePolicy)

Source code in prettyqt\widgets\graphicslayoutitem.py
@set_size_policy.register
def _(self, policy: QtWidgets.QSizePolicy):
    self.setSizePolicy(policy)

__bool__()

Source code in prettyqt\widgets\graphicslayoutitem.py
def __bool__(self):
    return not self.isEmpty()

__repr__()

Source code in prettyqt\widgets\graphicslayoutitem.py
def __repr__(self):
    return get_repr(self)

get_size_policy() -> widgets.SizePolicy

Source code in prettyqt\widgets\graphicslayoutitem.py
def get_size_policy(self) -> widgets.SizePolicy:
    qpol = self.sizePolicy()
    return widgets.SizePolicy.clone(qpol)

set_size_policy(horizontal: widgets.sizepolicy.SizePolicyStr, vertical: widgets.sizepolicy.SizePolicyStr, control_type: widgets.sizepolicy.ControlTypeStr = 'default')

Set the size policy.

Parameters:

Name Type Description Default
horizontal widgets.sizepolicy.SizePolicyStr

horizontal size policy

required
vertical widgets.sizepolicy.SizePolicyStr

vertical size policy

required
control_type widgets.sizepolicy.ControlTypeStr

control type associated with the widget

'default'
Source code in prettyqt\widgets\graphicslayoutitem.py
@functools.singledispatchmethod
def set_size_policy(
    self,
    horizontal: widgets.sizepolicy.SizePolicyStr,
    vertical: widgets.sizepolicy.SizePolicyStr,
    control_type: widgets.sizepolicy.ControlTypeStr = "default",
):
    """Set the size policy.

    Args:
        horizontal: horizontal size policy
        vertical: vertical size policy
        control_type: control type associated with the widget
    """
    h_policy = widgets.sizepolicy.SIZE_POLICY[horizontal]
    v_policy = widgets.sizepolicy.SIZE_POLICY[vertical]
    c = widgets.sizepolicy.CONTROL_TYPE[control_type]
    self.setSizePolicy(h_policy, v_policy, c)

GraphicsLayoutMixin

Bases: widgets.GraphicsLayoutItemMixin

Source code in prettyqt\widgets\graphicslayout.py
class GraphicsLayoutMixin(widgets.GraphicsLayoutItemMixin):
    def __getitem__(self, index: int) -> QtWidgets.QGraphicsItem:
        layoutitem = self.itemAt(index)
        return layoutitem.graphicsItem()

    def __setitem__(self, index: int, value: QtWidgets.QGraphicsItem):
        layoutitem = self.itemAt(index)
        layoutitem.setGraphicsItem(value)

    def __delitem__(self, index: int):
        self.removeAt(index)

    def __iter__(self) -> Iterator[QtWidgets.QGraphicsItem]:
        return iter(self[i] for i in range(self.count()))

    def __contains__(self, item):
        return item in self.get_children()

    def __len__(self):
        # for PySide2
        return self.count()

    def get_children(self) -> list[QtWidgets.QGraphicsItem]:
        return list(self)

    def set_margin(self, margin: int):
        self.setContentsMargins(margin, margin, margin, margin)

__contains__(item)

Source code in prettyqt\widgets\graphicslayout.py
def __contains__(self, item):
    return item in self.get_children()

__delitem__(index: int)

Source code in prettyqt\widgets\graphicslayout.py
def __delitem__(self, index: int):
    self.removeAt(index)

__getitem__(index: int) -> QtWidgets.QGraphicsItem

Source code in prettyqt\widgets\graphicslayout.py
def __getitem__(self, index: int) -> QtWidgets.QGraphicsItem:
    layoutitem = self.itemAt(index)
    return layoutitem.graphicsItem()

__iter__() -> Iterator[QtWidgets.QGraphicsItem]

Source code in prettyqt\widgets\graphicslayout.py
def __iter__(self) -> Iterator[QtWidgets.QGraphicsItem]:
    return iter(self[i] for i in range(self.count()))

__len__()

Source code in prettyqt\widgets\graphicslayout.py
def __len__(self):
    # for PySide2
    return self.count()

__setitem__(index: int, value: QtWidgets.QGraphicsItem)

Source code in prettyqt\widgets\graphicslayout.py
def __setitem__(self, index: int, value: QtWidgets.QGraphicsItem):
    layoutitem = self.itemAt(index)
    layoutitem.setGraphicsItem(value)

get_children() -> list[QtWidgets.QGraphicsItem]

Source code in prettyqt\widgets\graphicslayout.py
def get_children(self) -> list[QtWidgets.QGraphicsItem]:
    return list(self)

set_margin(margin: int)

Source code in prettyqt\widgets\graphicslayout.py
def set_margin(self, margin: int):
    self.setContentsMargins(margin, margin, margin, margin)

GraphicsLineItem

Bases: widgets.GraphicsItemMixin, QtWidgets.QGraphicsLineItem

Source code in prettyqt\widgets\graphicslineitem.py
class GraphicsLineItem(widgets.GraphicsItemMixin, QtWidgets.QGraphicsLineItem):
    def __repr__(self):
        return get_repr(self, self.get_line())

    def get_line(self) -> core.LineF:
        return core.LineF(self.line())

__repr__()

Source code in prettyqt\widgets\graphicslineitem.py
def __repr__(self):
    return get_repr(self, self.get_line())

get_line() -> core.LineF

Source code in prettyqt\widgets\graphicslineitem.py
def get_line(self) -> core.LineF:
    return core.LineF(self.line())

GraphicsLinearLayout

Bases: widgets.GraphicsLayoutMixin, QtWidgets.QGraphicsLinearLayout

Source code in prettyqt\widgets\graphicslinearlayout.py
class GraphicsLinearLayout(widgets.GraphicsLayoutMixin, QtWidgets.QGraphicsLinearLayout):
    def __init__(
        self,
        orientation: (constants.OrientationStr | QtCore.Qt.Orientation) = "horizontal",
        parent: QtWidgets.QGraphicsLayoutItem | None = None,
    ):
        if isinstance(orientation, QtCore.Qt.Orientation):
            ori = orientation
        else:
            ori = constants.ORIENTATION[orientation]
        super().__init__(ori, parent)

    # def serialize_fields(self):
    #     return dict(items=self.get_children())

    # def __setstate__(self, state):
    #     for item, pos in zip(state["widgets"], state["positions"]):
    #         x, y = pos
    #         self[x, y] = item

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    def __add__(self, other):
        self[self.count()] = other
        return self

__add__(other)

Source code in prettyqt\widgets\graphicslinearlayout.py
def __add__(self, other):
    self[self.count()] = other
    return self

__init__(orientation: constants.OrientationStr | QtCore.Qt.Orientation = 'horizontal', parent: QtWidgets.QGraphicsLayoutItem | None = None)

Source code in prettyqt\widgets\graphicslinearlayout.py
def __init__(
    self,
    orientation: (constants.OrientationStr | QtCore.Qt.Orientation) = "horizontal",
    parent: QtWidgets.QGraphicsLayoutItem | None = None,
):
    if isinstance(orientation, QtCore.Qt.Orientation):
        ori = orientation
    else:
        ori = constants.ORIENTATION[orientation]
    super().__init__(ori, parent)

GraphicsObject

Bases: GraphicsObjectMixin, QtWidgets.QGraphicsObject

Source code in prettyqt\widgets\graphicsobject.py
class GraphicsObject(GraphicsObjectMixin, QtWidgets.QGraphicsObject):
    pass

GraphicsObjectMixin

Bases: core.ObjectMixin, widgets.GraphicsItemMixin

Source code in prettyqt\widgets\graphicsobject.py
class GraphicsObjectMixin(core.ObjectMixin, widgets.GraphicsItemMixin):
    pass

GraphicsOpacityEffect

Bases: widgets.GraphicsEffectMixin, QtWidgets.QGraphicsOpacityEffect

Source code in prettyqt\widgets\graphicsopacityeffect.py
class GraphicsOpacityEffect(
    widgets.GraphicsEffectMixin, QtWidgets.QGraphicsOpacityEffect
):
    def get_opacity_mask(self) -> gui.Brush:
        return gui.Brush(self.opacityMask())

get_opacity_mask() -> gui.Brush

Source code in prettyqt\widgets\graphicsopacityeffect.py
def get_opacity_mask(self) -> gui.Brush:
    return gui.Brush(self.opacityMask())

GraphicsPathItem

Bases: widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsPathItem

Source code in prettyqt\widgets\graphicspathitem.py
class GraphicsPathItem(
    widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsPathItem
):
    pass

GraphicsPixmapItem

Bases: widgets.GraphicsItemMixin, QtWidgets.QGraphicsPixmapItem

Source code in prettyqt\widgets\graphicspixmapitem.py
class GraphicsPixmapItem(widgets.GraphicsItemMixin, QtWidgets.QGraphicsPixmapItem):
    def set_transformation_mode(self, mode: constants.TransformationModeStr):
        """Set transformation mode.

        Args:
            mode: transformation mode to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode not in constants.TRANSFORMATION_MODE:
            raise InvalidParamError(mode, constants.TRANSFORMATION_MODE)
        self.setTransformationMode(constants.TRANSFORMATION_MODE[mode])

    def get_transformation_mode(self) -> constants.TransformationModeStr:
        """Return current transformation mode.

        Returns:
            transformation mode
        """
        return constants.TRANSFORMATION_MODE.inverse[self.transformationMode()]

    def set_shape_mode(self, mode: ShapeModeStr):
        """Set shape mode.

        Args:
            mode: shape mode to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode not in SHAPE_MODE:
            raise InvalidParamError(mode, SHAPE_MODE)
        self.setShapeMode(SHAPE_MODE[mode])

    def get_shape_mode(self) -> ShapeModeStr:
        """Return current shape mode.

        Returns:
            shape mode
        """
        return SHAPE_MODE.inverse[self.shapeMode()]

    def get_pixmap(self) -> gui.Pixmap | None:
        pix = self.pixmap()
        return None if pix.isNull() else gui.Pixmap(pix)

get_pixmap() -> gui.Pixmap | None

Source code in prettyqt\widgets\graphicspixmapitem.py
def get_pixmap(self) -> gui.Pixmap | None:
    pix = self.pixmap()
    return None if pix.isNull() else gui.Pixmap(pix)

get_shape_mode() -> ShapeModeStr

Return current shape mode.

Returns:

Type Description
ShapeModeStr

shape mode

Source code in prettyqt\widgets\graphicspixmapitem.py
def get_shape_mode(self) -> ShapeModeStr:
    """Return current shape mode.

    Returns:
        shape mode
    """
    return SHAPE_MODE.inverse[self.shapeMode()]

get_transformation_mode() -> constants.TransformationModeStr

Return current transformation mode.

Returns:

Type Description
constants.TransformationModeStr

transformation mode

Source code in prettyqt\widgets\graphicspixmapitem.py
def get_transformation_mode(self) -> constants.TransformationModeStr:
    """Return current transformation mode.

    Returns:
        transformation mode
    """
    return constants.TRANSFORMATION_MODE.inverse[self.transformationMode()]

set_shape_mode(mode: ShapeModeStr)

Set shape mode.

Parameters:

Name Type Description Default
mode ShapeModeStr

shape mode to use

required

Raises:

Type Description
InvalidParamError

mode does not exist

Source code in prettyqt\widgets\graphicspixmapitem.py
def set_shape_mode(self, mode: ShapeModeStr):
    """Set shape mode.

    Args:
        mode: shape mode to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode not in SHAPE_MODE:
        raise InvalidParamError(mode, SHAPE_MODE)
    self.setShapeMode(SHAPE_MODE[mode])

set_transformation_mode(mode: constants.TransformationModeStr)

Set transformation mode.

Parameters:

Name Type Description Default
mode constants.TransformationModeStr

transformation mode to use

required

Raises:

Type Description
InvalidParamError

mode does not exist

Source code in prettyqt\widgets\graphicspixmapitem.py
def set_transformation_mode(self, mode: constants.TransformationModeStr):
    """Set transformation mode.

    Args:
        mode: transformation mode to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode not in constants.TRANSFORMATION_MODE:
        raise InvalidParamError(mode, constants.TRANSFORMATION_MODE)
    self.setTransformationMode(constants.TRANSFORMATION_MODE[mode])

GraphicsPolygonItem

Bases: widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsPolygonItem

Source code in prettyqt\widgets\graphicspolygonitem.py
class GraphicsPolygonItem(
    widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsPolygonItem
):
    def serialize_fields(self):
        return dict(polygon=self.get_polygon(), fill_rule=self.get_fill_rule())

    def get_polygon(self) -> gui.PolygonF:
        return gui.PolygonF(self.polygon())

    def set_fill_rule(self, rule: constants.FillRuleStr):
        if rule not in constants.FILL_RULE:
            raise InvalidParamError(rule, constants.FILL_RULE)
        self.setFillRule(constants.FILL_RULE[rule])

    def get_fill_rule(self) -> constants.FillRuleStr:
        return constants.FILL_RULE.inverse[self.fillRule()]

get_fill_rule() -> constants.FillRuleStr

Source code in prettyqt\widgets\graphicspolygonitem.py
def get_fill_rule(self) -> constants.FillRuleStr:
    return constants.FILL_RULE.inverse[self.fillRule()]

get_polygon() -> gui.PolygonF

Source code in prettyqt\widgets\graphicspolygonitem.py
def get_polygon(self) -> gui.PolygonF:
    return gui.PolygonF(self.polygon())

serialize_fields()

Source code in prettyqt\widgets\graphicspolygonitem.py
def serialize_fields(self):
    return dict(polygon=self.get_polygon(), fill_rule=self.get_fill_rule())

set_fill_rule(rule: constants.FillRuleStr)

Source code in prettyqt\widgets\graphicspolygonitem.py
def set_fill_rule(self, rule: constants.FillRuleStr):
    if rule not in constants.FILL_RULE:
        raise InvalidParamError(rule, constants.FILL_RULE)
    self.setFillRule(constants.FILL_RULE[rule])

GraphicsProxyWidget

Bases: widgets.GraphicsWidgetMixin, QtWidgets.QGraphicsProxyWidget

Source code in prettyqt\widgets\graphicsproxywidget.py
class GraphicsProxyWidget(widgets.GraphicsWidgetMixin, QtWidgets.QGraphicsProxyWidget):
    pass

GraphicsRectItem

Bases: widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsRectItem

Source code in prettyqt\widgets\graphicsrectitem.py
class GraphicsRectItem(
    widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsRectItem
):
    def __repr__(self):
        return get_repr(self, self.get_rect())

    def get_rect(self):
        return core.RectF(self.rect())

    def serialize_fields(self):
        return dict(rect=self.get_rect())

    def __setstate__(self, state):
        super().__setstate__(state)
        self.setRect(state["rect"])

__repr__()

Source code in prettyqt\widgets\graphicsrectitem.py
def __repr__(self):
    return get_repr(self, self.get_rect())

__setstate__(state)

Source code in prettyqt\widgets\graphicsrectitem.py
def __setstate__(self, state):
    super().__setstate__(state)
    self.setRect(state["rect"])

get_rect()

Source code in prettyqt\widgets\graphicsrectitem.py
def get_rect(self):
    return core.RectF(self.rect())

serialize_fields()

Source code in prettyqt\widgets\graphicsrectitem.py
def serialize_fields(self):
    return dict(rect=self.get_rect())

GraphicsRotation

Bases: widgets.GraphicsTransformMixin, QtWidgets.QGraphicsRotation

Source code in prettyqt\widgets\graphicsrotation.py
class GraphicsRotation(widgets.GraphicsTransformMixin, QtWidgets.QGraphicsRotation):
    def set_axis(self, axis: constants.AxisStr):
        if axis not in constants.AXIS:
            raise InvalidParamError(axis, constants.AXIS)
        self.setAxis(constants.AXIS[axis])

    def set_origin(self, origin: datatypes.VectorType):
        if not isinstance(origin, QtGui.QVector3D):
            origin = QtGui.QVector3D(*origin)
        self.setOrigin(origin)

set_axis(axis: constants.AxisStr)

Source code in prettyqt\widgets\graphicsrotation.py
def set_axis(self, axis: constants.AxisStr):
    if axis not in constants.AXIS:
        raise InvalidParamError(axis, constants.AXIS)
    self.setAxis(constants.AXIS[axis])

set_origin(origin: datatypes.VectorType)

Source code in prettyqt\widgets\graphicsrotation.py
def set_origin(self, origin: datatypes.VectorType):
    if not isinstance(origin, QtGui.QVector3D):
        origin = QtGui.QVector3D(*origin)
    self.setOrigin(origin)

GraphicsScale

Bases: widgets.GraphicsTransformMixin, QtWidgets.QGraphicsScale

Source code in prettyqt\widgets\graphicsscale.py
class GraphicsScale(widgets.GraphicsTransformMixin, QtWidgets.QGraphicsScale):
    def set_origin(self, origin: datatypes.VectorType):
        if not isinstance(origin, QtGui.QVector3D):
            origin = QtGui.QVector3D(*origin)
        self.setOrigin(origin)

set_origin(origin: datatypes.VectorType)

Source code in prettyqt\widgets\graphicsscale.py
def set_origin(self, origin: datatypes.VectorType):
    if not isinstance(origin, QtGui.QVector3D):
        origin = QtGui.QVector3D(*origin)
    self.setOrigin(origin)

GraphicsScene

Bases: core.ObjectMixin, QtWidgets.QGraphicsScene

Source code in prettyqt\widgets\graphicsscene.py
class GraphicsScene(core.ObjectMixin, QtWidgets.QGraphicsScene):
    def serialize_fields(self):
        return dict(
            items=self.items(),
            background_brush=self.get_background_brush(),
            foreground_brush=self.get_foreground_brush(),
            item_index_method=self.get_item_index_method(),
            minimum_render_size=self.minimumRenderSize(),
            palette=self.get_palette(),
            bsp_tree_depth=self.bspTreeDepth(),
            focus_on_touch=self.focusOnTouch(),
            sticky_focus=self.stickyFocus(),
            scene_rect=core.RectF(self.sceneRect()),
            font=self.get_font(),
        )

    def __setitem__(self, state):
        # self.setItem
        self.setBackgroundBrush(state["background_brush"])
        self.setForegroundBrush(state["foreground_brush"])
        self.set_item_index_method(state["item_index_method"])
        self.setMinimumRenderSize(state["minimum_render_size"])
        self.setPalette(state["palette"])
        self.setBspTreeDepth(state["bsp_tree_depth"])
        self.setFocusOnTouchRelease(state["focus_on_touch"])
        self.setStickyFocus(state["focus_on_touch"])
        self.setSceneRect(state["scene_rect"])
        self.setFont(state["font"])

    def __getitem__(self, index: int) -> QtWidgets.QGraphicsItem:
        return self.items()[index]

    def get_palette(self) -> gui.Palette:
        return gui.Palette(self.palette())

    def get_font(self) -> gui.Font:
        return gui.Font(self.font())

    def get_background_brush(self) -> gui.Brush:
        return gui.Brush(self.backgroundBrush())

    def get_foreground_brush(self) -> gui.Brush:
        return gui.Brush(self.foregroundBrush())

    def add(self, item) -> QtWidgets.QGraphicsItem:
        match item:
            case QtWidgets.QGraphicsItem():
                self.addItem(item)
                return item
            case QtGui.QPixmap():
                return self.add_pixmap(item)
            case QtGui.QPainterPath():
                return self.add_path(item)
            case QtGui.QPolygonF():
                return self.add_polygon(item)
            case QtCore.QRectF():
                return self.add_rect(item)
            case QtCore.QLine():
                return self.add_line(item)
            case str():
                return self.add_text(item)
            case QtWidgets.QWidget():
                return self.add_widget(item)
            case _:
                raise TypeError(item)

    def add_pixmap(self, pixmap: QtGui.QPixmap) -> widgets.GraphicsPixmapItem:
        g_item = widgets.GraphicsPixmapItem()
        g_item.setPixmap(pixmap)
        self.addItem(g_item)
        return g_item

    def add_polygon(
        self,
        polygon: QtGui.QPolygonF | QtGui.QPolygon,
        pen: QtGui.QPen | None = None,
        brush: QtGui.QBrush | None = None,
    ) -> widgets.GraphicsPolygonItem:
        if isinstance(polygon, QtGui.QPolygon):
            polygon = gui.PolygonF(polygon)
        g_item = widgets.GraphicsPolygonItem()
        g_item.setPolygon(polygon)
        if brush is not None:
            g_item.setBrush(brush)
        if pen is not None:
            g_item.setPen(pen)
        self.addItem(g_item)
        return g_item

    def add_path(
        self,
        path: QtGui.QPainterPath,
        pen: QtGui.QPen | None = None,
        brush: QtGui.QBrush | None = None,
    ) -> widgets.GraphicsPathItem:
        g_item = widgets.GraphicsPathItem()
        g_item.setPath(path)
        if brush is not None:
            g_item.setBrush(brush)
        if pen is not None:
            g_item.setPen(pen)
        self.addItem(g_item)
        return g_item

    def add_rect(
        self,
        rect: datatypes.RectType | datatypes.RectFType,
        pen: QtGui.QPen | None = None,
        brush: QtGui.QBrush | None = None,
    ) -> widgets.GraphicsRectItem:
        if isinstance(rect, QtCore.QRect):
            rect = core.RectF(rect)
        elif isinstance(rect, tuple):
            rect = core.RectF(*rect)
        g_item = widgets.GraphicsRectItem()
        g_item.setRect(rect)
        if brush is not None:
            g_item.setBrush(brush)
        if pen is not None:
            g_item.setPen(pen)
        self.addItem(g_item)
        return g_item

    def add_line(
        self,
        line: QtCore.QLineF | QtCore.QLine | tuple[float, float, float, float],
        pen: QtGui.QPen | None = None,
    ) -> widgets.GraphicsLineItem:
        if isinstance(line, QtCore.QLine):
            line = core.LineF(line)
        elif isinstance(line, tuple):
            line = core.LineF(*line)
        g_item = widgets.GraphicsLineItem()
        g_item.setLine(line)
        if pen is not None:
            g_item.setPen(pen)
        self.addItem(g_item)
        return g_item

    def add_ellipse(
        self,
        ellipse: datatypes.RectType | datatypes.RectFType,
        pen: QtGui.QPen | None = None,
        brush: QtGui.QBrush | None = None,
    ) -> widgets.GraphicsEllipseItem:
        if isinstance(ellipse, QtCore.QRect):
            ellipse = core.RectF(ellipse)
        elif isinstance(ellipse, tuple):
            ellipse = core.RectF(*ellipse)
        g_item = widgets.GraphicsEllipseItem()
        g_item.setRect(ellipse)
        if brush is not None:
            g_item.setBrush(brush)
        if pen is not None:
            g_item.setPen(pen)
        self.addItem(g_item)
        return g_item

    def add_text(
        self, text: str, font: QtGui.QFont | None = None
    ) -> widgets.GraphicsTextItem:
        g_item = widgets.GraphicsTextItem()
        g_item.setPlainText(text)
        if font is not None:
            g_item.setFont(font)
        self.addItem(g_item)
        return g_item

    def add_simple_text(
        self, text: str, font: QtGui.QFont | None = None
    ) -> widgets.GraphicsSimpleTextItem:
        g_item = widgets.GraphicsSimpleTextItem()
        g_item.setText(text)
        if font is not None:
            g_item.setFont(font)
        self.addItem(g_item)
        return g_item

    def add_widget(self, widget: QtWidgets.QWidget) -> widgets.GraphicsProxyWidget:
        g_item = widgets.GraphicsProxyWidget()
        g_item.setWidget(widget)
        self.addItem(g_item)
        return g_item

    def colliding_items(
        self,
        item: QtWidgets.QGraphicsItem,
        mode: constants.ItemSelectionModeStr = "intersects_shape",
    ) -> list[QtWidgets.QGraphicsItem]:
        if mode not in constants.ITEM_SELECTION_MODE:
            raise InvalidParamError(mode, constants.ITEM_SELECTION_MODE)
        return self.collidingItems(item, constants.ITEM_SELECTION_MODE[mode])

    def add_item_group(
        self, *items: QtWidgets.QGraphicsItem
    ) -> widgets.GraphicsItemGroup:
        group = widgets.GraphicsItemGroup()
        for item in items:
            group.addToGroup(item)
        return group

    def set_item_index_method(self, method: ItemIndexMethodStr):
        """Set item index method.

        Args:
            method: item index method to use

        Raises:
            InvalidParamError: invalid item index method
        """
        if method not in ITEM_INDEX_METHOD:
            raise InvalidParamError(method, ITEM_INDEX_METHOD)
        self.setItemIndexMethod(ITEM_INDEX_METHOD[method])

    def get_item_index_method(self) -> ItemIndexMethodStr:
        """Return item index method.

        Returns:
            item index method
        """
        return ITEM_INDEX_METHOD.inverse[self.itemIndexMethod()]

__getitem__(index: int) -> QtWidgets.QGraphicsItem

Source code in prettyqt\widgets\graphicsscene.py
def __getitem__(self, index: int) -> QtWidgets.QGraphicsItem:
    return self.items()[index]

__setitem__(state)

Source code in prettyqt\widgets\graphicsscene.py
def __setitem__(self, state):
    # self.setItem
    self.setBackgroundBrush(state["background_brush"])
    self.setForegroundBrush(state["foreground_brush"])
    self.set_item_index_method(state["item_index_method"])
    self.setMinimumRenderSize(state["minimum_render_size"])
    self.setPalette(state["palette"])
    self.setBspTreeDepth(state["bsp_tree_depth"])
    self.setFocusOnTouchRelease(state["focus_on_touch"])
    self.setStickyFocus(state["focus_on_touch"])
    self.setSceneRect(state["scene_rect"])
    self.setFont(state["font"])

add(item) -> QtWidgets.QGraphicsItem

Source code in prettyqt\widgets\graphicsscene.py
def add(self, item) -> QtWidgets.QGraphicsItem:
    match item:
        case QtWidgets.QGraphicsItem():
            self.addItem(item)
            return item
        case QtGui.QPixmap():
            return self.add_pixmap(item)
        case QtGui.QPainterPath():
            return self.add_path(item)
        case QtGui.QPolygonF():
            return self.add_polygon(item)
        case QtCore.QRectF():
            return self.add_rect(item)
        case QtCore.QLine():
            return self.add_line(item)
        case str():
            return self.add_text(item)
        case QtWidgets.QWidget():
            return self.add_widget(item)
        case _:
            raise TypeError(item)

add_ellipse(ellipse: datatypes.RectType | datatypes.RectFType, pen: QtGui.QPen | None = None, brush: QtGui.QBrush | None = None) -> widgets.GraphicsEllipseItem

Source code in prettyqt\widgets\graphicsscene.py
def add_ellipse(
    self,
    ellipse: datatypes.RectType | datatypes.RectFType,
    pen: QtGui.QPen | None = None,
    brush: QtGui.QBrush | None = None,
) -> widgets.GraphicsEllipseItem:
    if isinstance(ellipse, QtCore.QRect):
        ellipse = core.RectF(ellipse)
    elif isinstance(ellipse, tuple):
        ellipse = core.RectF(*ellipse)
    g_item = widgets.GraphicsEllipseItem()
    g_item.setRect(ellipse)
    if brush is not None:
        g_item.setBrush(brush)
    if pen is not None:
        g_item.setPen(pen)
    self.addItem(g_item)
    return g_item

add_item_group(*items: QtWidgets.QGraphicsItem) -> widgets.GraphicsItemGroup

Source code in prettyqt\widgets\graphicsscene.py
def add_item_group(
    self, *items: QtWidgets.QGraphicsItem
) -> widgets.GraphicsItemGroup:
    group = widgets.GraphicsItemGroup()
    for item in items:
        group.addToGroup(item)
    return group

add_line(line: QtCore.QLineF | QtCore.QLine | tuple[float, float, float, float], pen: QtGui.QPen | None = None) -> widgets.GraphicsLineItem

Source code in prettyqt\widgets\graphicsscene.py
def add_line(
    self,
    line: QtCore.QLineF | QtCore.QLine | tuple[float, float, float, float],
    pen: QtGui.QPen | None = None,
) -> widgets.GraphicsLineItem:
    if isinstance(line, QtCore.QLine):
        line = core.LineF(line)
    elif isinstance(line, tuple):
        line = core.LineF(*line)
    g_item = widgets.GraphicsLineItem()
    g_item.setLine(line)
    if pen is not None:
        g_item.setPen(pen)
    self.addItem(g_item)
    return g_item

add_path(path: QtGui.QPainterPath, pen: QtGui.QPen | None = None, brush: QtGui.QBrush | None = None) -> widgets.GraphicsPathItem

Source code in prettyqt\widgets\graphicsscene.py
def add_path(
    self,
    path: QtGui.QPainterPath,
    pen: QtGui.QPen | None = None,
    brush: QtGui.QBrush | None = None,
) -> widgets.GraphicsPathItem:
    g_item = widgets.GraphicsPathItem()
    g_item.setPath(path)
    if brush is not None:
        g_item.setBrush(brush)
    if pen is not None:
        g_item.setPen(pen)
    self.addItem(g_item)
    return g_item

add_pixmap(pixmap: QtGui.QPixmap) -> widgets.GraphicsPixmapItem

Source code in prettyqt\widgets\graphicsscene.py
def add_pixmap(self, pixmap: QtGui.QPixmap) -> widgets.GraphicsPixmapItem:
    g_item = widgets.GraphicsPixmapItem()
    g_item.setPixmap(pixmap)
    self.addItem(g_item)
    return g_item

add_polygon(polygon: QtGui.QPolygonF | QtGui.QPolygon, pen: QtGui.QPen | None = None, brush: QtGui.QBrush | None = None) -> widgets.GraphicsPolygonItem

Source code in prettyqt\widgets\graphicsscene.py
def add_polygon(
    self,
    polygon: QtGui.QPolygonF | QtGui.QPolygon,
    pen: QtGui.QPen | None = None,
    brush: QtGui.QBrush | None = None,
) -> widgets.GraphicsPolygonItem:
    if isinstance(polygon, QtGui.QPolygon):
        polygon = gui.PolygonF(polygon)
    g_item = widgets.GraphicsPolygonItem()
    g_item.setPolygon(polygon)
    if brush is not None:
        g_item.setBrush(brush)
    if pen is not None:
        g_item.setPen(pen)
    self.addItem(g_item)
    return g_item

add_rect(rect: datatypes.RectType | datatypes.RectFType, pen: QtGui.QPen | None = None, brush: QtGui.QBrush | None = None) -> widgets.GraphicsRectItem

Source code in prettyqt\widgets\graphicsscene.py
def add_rect(
    self,
    rect: datatypes.RectType | datatypes.RectFType,
    pen: QtGui.QPen | None = None,
    brush: QtGui.QBrush | None = None,
) -> widgets.GraphicsRectItem:
    if isinstance(rect, QtCore.QRect):
        rect = core.RectF(rect)
    elif isinstance(rect, tuple):
        rect = core.RectF(*rect)
    g_item = widgets.GraphicsRectItem()
    g_item.setRect(rect)
    if brush is not None:
        g_item.setBrush(brush)
    if pen is not None:
        g_item.setPen(pen)
    self.addItem(g_item)
    return g_item

add_simple_text(text: str, font: QtGui.QFont | None = None) -> widgets.GraphicsSimpleTextItem

Source code in prettyqt\widgets\graphicsscene.py
def add_simple_text(
    self, text: str, font: QtGui.QFont | None = None
) -> widgets.GraphicsSimpleTextItem:
    g_item = widgets.GraphicsSimpleTextItem()
    g_item.setText(text)
    if font is not None:
        g_item.setFont(font)
    self.addItem(g_item)
    return g_item

add_text(text: str, font: QtGui.QFont | None = None) -> widgets.GraphicsTextItem

Source code in prettyqt\widgets\graphicsscene.py
def add_text(
    self, text: str, font: QtGui.QFont | None = None
) -> widgets.GraphicsTextItem:
    g_item = widgets.GraphicsTextItem()
    g_item.setPlainText(text)
    if font is not None:
        g_item.setFont(font)
    self.addItem(g_item)
    return g_item

add_widget(widget: QtWidgets.QWidget) -> widgets.GraphicsProxyWidget

Source code in prettyqt\widgets\graphicsscene.py
def add_widget(self, widget: QtWidgets.QWidget) -> widgets.GraphicsProxyWidget:
    g_item = widgets.GraphicsProxyWidget()
    g_item.setWidget(widget)
    self.addItem(g_item)
    return g_item

colliding_items(item: QtWidgets.QGraphicsItem, mode: constants.ItemSelectionModeStr = 'intersects_shape') -> list[QtWidgets.QGraphicsItem]

Source code in prettyqt\widgets\graphicsscene.py
def colliding_items(
    self,
    item: QtWidgets.QGraphicsItem,
    mode: constants.ItemSelectionModeStr = "intersects_shape",
) -> list[QtWidgets.QGraphicsItem]:
    if mode not in constants.ITEM_SELECTION_MODE:
        raise InvalidParamError(mode, constants.ITEM_SELECTION_MODE)
    return self.collidingItems(item, constants.ITEM_SELECTION_MODE[mode])

get_background_brush() -> gui.Brush

Source code in prettyqt\widgets\graphicsscene.py
def get_background_brush(self) -> gui.Brush:
    return gui.Brush(self.backgroundBrush())

get_font() -> gui.Font

Source code in prettyqt\widgets\graphicsscene.py
def get_font(self) -> gui.Font:
    return gui.Font(self.font())

get_foreground_brush() -> gui.Brush

Source code in prettyqt\widgets\graphicsscene.py
def get_foreground_brush(self) -> gui.Brush:
    return gui.Brush(self.foregroundBrush())

get_item_index_method() -> ItemIndexMethodStr

Return item index method.

Returns:

Type Description
ItemIndexMethodStr

item index method

Source code in prettyqt\widgets\graphicsscene.py
def get_item_index_method(self) -> ItemIndexMethodStr:
    """Return item index method.

    Returns:
        item index method
    """
    return ITEM_INDEX_METHOD.inverse[self.itemIndexMethod()]

get_palette() -> gui.Palette

Source code in prettyqt\widgets\graphicsscene.py
def get_palette(self) -> gui.Palette:
    return gui.Palette(self.palette())

serialize_fields()

Source code in prettyqt\widgets\graphicsscene.py
def serialize_fields(self):
    return dict(
        items=self.items(),
        background_brush=self.get_background_brush(),
        foreground_brush=self.get_foreground_brush(),
        item_index_method=self.get_item_index_method(),
        minimum_render_size=self.minimumRenderSize(),
        palette=self.get_palette(),
        bsp_tree_depth=self.bspTreeDepth(),
        focus_on_touch=self.focusOnTouch(),
        sticky_focus=self.stickyFocus(),
        scene_rect=core.RectF(self.sceneRect()),
        font=self.get_font(),
    )

set_item_index_method(method: ItemIndexMethodStr)

Set item index method.

Parameters:

Name Type Description Default
method ItemIndexMethodStr

item index method to use

required

Raises:

Type Description
InvalidParamError

invalid item index method

Source code in prettyqt\widgets\graphicsscene.py
def set_item_index_method(self, method: ItemIndexMethodStr):
    """Set item index method.

    Args:
        method: item index method to use

    Raises:
        InvalidParamError: invalid item index method
    """
    if method not in ITEM_INDEX_METHOD:
        raise InvalidParamError(method, ITEM_INDEX_METHOD)
    self.setItemIndexMethod(ITEM_INDEX_METHOD[method])

GraphicsSimpleTextItem

Bases: widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsSimpleTextItem

Source code in prettyqt\widgets\graphicssimpletextitem.py
class GraphicsSimpleTextItem(
    widgets.AbstractGraphicsShapeItemMixin, QtWidgets.QGraphicsSimpleTextItem
):
    def __repr__(self):
        return get_repr(self, self.text())

__repr__()

Source code in prettyqt\widgets\graphicssimpletextitem.py
def __repr__(self):
    return get_repr(self, self.text())

GraphicsTextItem

Bases: widgets.GraphicsObjectMixin, QtWidgets.QGraphicsTextItem

Source code in prettyqt\widgets\graphicstextitem.py
class GraphicsTextItem(widgets.GraphicsObjectMixin, QtWidgets.QGraphicsTextItem):
    def __repr__(self):
        return get_repr(self, self.toPlainText())

__repr__()

Source code in prettyqt\widgets\graphicstextitem.py
def __repr__(self):
    return get_repr(self, self.toPlainText())

GraphicsTransform

Bases: GraphicsTransformMixin, QtWidgets.QGraphicsTransform

Source code in prettyqt\widgets\graphicstransform.py
class GraphicsTransform(GraphicsTransformMixin, QtWidgets.QGraphicsTransform):
    pass

GraphicsTransformMixin

Bases: core.ObjectMixin

Source code in prettyqt\widgets\graphicstransform.py
class GraphicsTransformMixin(core.ObjectMixin):
    pass

GraphicsView

Bases: GraphicsViewMixin, QtWidgets.QGraphicsView

Source code in prettyqt\widgets\graphicsview.py
class GraphicsView(GraphicsViewMixin, QtWidgets.QGraphicsView):
    pass

GraphicsViewMixin

Bases: widgets.AbstractScrollAreaMixin

Source code in prettyqt\widgets\graphicsview.py
class GraphicsViewMixin(widgets.AbstractScrollAreaMixin):
    def serialize_fields(self):
        return dict(
            scene=self.scene(),
            background_brush=self.get_background_brush(),
            foreground_brush=self.get_foreground_brush(),
            transformation_anchor=self.get_transformation_anchor(),
            resize_anchor=self.get_resize_anchor(),
            viewport_update_mode=self.get_viewport_update_mode(),
            drag_mode=self.get_drag_mode(),
            rubberband_selection_mode=self.get_rubberband_selection_mode(),
            scene_rect=core.RectF(self.sceneRect()),
            cache_mode=self.get_cache_mode(),
            is_interactive=self.isInteractive(),
        )

    def __setitem__(self, state):
        super().__setstate__(state)
        self.setScene(state["scene"])
        self.setBackgroundBrush(state["background_brush"])
        self.setForegroundBrush(state["foreground_brush"])
        self.set_transformation_anchor(state["transformation_anchor"])
        self.set_resize_anchor(state["resicze_anchor"])
        self.set_viewport_update_mode(state["viewport_update_mode"])
        self.set_drag_mode(state["drag_mode"])
        self.set_rubberband_selection_mode(state["rubberband_selection_mode"])
        self.setSceneRect(state["scene_rect"])
        self.set_cache_mode(state["cache_mode"])
        self.setInteractive(state["is_interactive"])

    def __getitem__(self, index: int) -> QtWidgets.QGraphicsItem:
        return self.items()[index]

    def get_background_brush(self) -> gui.Brush:
        return gui.Brush(self.backgroundBrush())

    def get_foreground_brush(self) -> gui.Brush:
        return gui.Brush(self.foregroundBrush())

    def invalidate_scene(
        self, rect: QtCore.QRectF, layer: widgets.graphicsscene.SceneLayerStr = "all"
    ):
        if layer not in widgets.graphicsscene.SCENE_LAYER:
            raise InvalidParamError(layer, widgets.graphicsscene.SCENE_LAYER)
        self.invalidateScene(rect, widgets.graphicsscene.SCENE_LAYER[layer])

    def set_transformation_anchor(self, mode: ViewportAnchorStr):
        """Set how the view should position the scene during transformations.

        Args:
            mode: transformation anchor to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode not in VIEWPORT_ANCHOR:
            raise InvalidParamError(mode, VIEWPORT_ANCHOR)
        self.setTransformationAnchor(VIEWPORT_ANCHOR[mode])

    def get_transformation_anchor(self) -> ViewportAnchorStr:
        """Return current transformation anchor.

        Returns:
            viewport anchor
        """
        return VIEWPORT_ANCHOR.inverse[self.transformationAnchor()]

    def set_transform(self, transform: datatypes.TransformType, combine: bool = False):
        if isinstance(transform, tuple):
            transform = gui.Transform(*transform)
        self.setTransform(transform, combine)

    def set_resize_anchor(self, mode: ViewportAnchorStr):
        """Set how the view should position the scene during resizes.

        Args:
            mode: resize anchor to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode not in VIEWPORT_ANCHOR:
            raise InvalidParamError(mode, VIEWPORT_ANCHOR)
        self.setResizeAnchor(VIEWPORT_ANCHOR[mode])

    def get_resize_anchor(self) -> ViewportAnchorStr:
        """Return current resize anchor.

        Returns:
            resize anchor
        """
        return VIEWPORT_ANCHOR.inverse[self.resizeAnchor()]

    def set_viewport_update_mode(self, mode: ViewportUpdateModeStr):
        """Set how the viewport should update its contents.

        Args:
            mode: viewport update mode to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode not in VIEWPORT_UPDATE_MODE:
            raise InvalidParamError(mode, VIEWPORT_UPDATE_MODE)
        self.setViewportUpdateMode(VIEWPORT_UPDATE_MODE[mode])

    def get_viewport_update_mode(self) -> ViewportUpdateModeStr:
        """Return current viewport update mode.

        Returns:
            viewport update mode
        """
        return VIEWPORT_UPDATE_MODE.inverse[self.viewportUpdateMode()]

    def set_drag_mode(self, mode: DragModeStr):
        """Set the behavior for dragging the mouse while the left mouse button is pressed.

        Args:
            mode: drag mode to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode not in DRAG_MODE:
            raise InvalidParamError(mode, DRAG_MODE)
        self.setDragMode(DRAG_MODE[mode])

    def get_drag_mode(self) -> DragModeStr:
        """Return current drag mode.

        Returns:
            drag mode
        """
        return DRAG_MODE.inverse[self.dragMode()]

    def set_rubberband_selection_mode(self, mode: constants.ItemSelectionModeStr):
        """Set the behavior for selecting items with a rubber band selection rectangle.

        Args:
            mode: rubberband selection mode to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode not in constants.ITEM_SELECTION_MODE:
            raise InvalidParamError(mode, constants.ITEM_SELECTION_MODE)
        self.setRubberBandSelectionMode(constants.ITEM_SELECTION_MODE[mode])

    def get_rubberband_selection_mode(self) -> constants.ItemSelectionModeStr:
        """Return current rubberband selection mode.

        Returns:
            rubberband selection mode
        """
        return constants.ITEM_SELECTION_MODE.inverse[self.rubberBandSelectionMode()]

    def set_cache_mode(self, mode: CacheModeStr):
        """Set the cache mode.

        Args:
            mode: cache mode to use

        Raises:
            InvalidParamError: mode does not exist
        """
        if mode not in CACHE_MODES:
            raise InvalidParamError(mode, CACHE_MODES)
        self.setCacheMode(CACHE_MODES[mode])

    def get_cache_mode(self) -> CacheModeStr:
        """Return current cache mode.

        Returns:
            cache mode
        """
        return CACHE_MODES.inverse[self.cacheMode()]

    def set_optimization_flags(self, *items: OptimizationFlagStr):
        for item in items:
            if item not in OPTIMIZATION_FLAGS:
                raise InvalidParamError(item, OPTIMIZATION_FLAGS)
        flags = helpers.merge_flags(items, OPTIMIZATION_FLAGS)
        self.setOptimizationFlags(flags)

    def get_optimization_flags(self) -> list[OptimizationFlagStr]:
        return OPTIMIZATION_FLAGS.get_list(self.optimizationFlags())

__getitem__(index: int) -> QtWidgets.QGraphicsItem

Source code in prettyqt\widgets\graphicsview.py
def __getitem__(self, index: int) -> QtWidgets.QGraphicsItem:
    return self.items()[index]

__setitem__(state)

Source code in prettyqt\widgets\graphicsview.py
def __setitem__(self, state):
    super().__setstate__(state)
    self.setScene(state["scene"])
    self.setBackgroundBrush(state["background_brush"])
    self.setForegroundBrush(state["foreground_brush"])
    self.set_transformation_anchor(state["transformation_anchor"])
    self.set_resize_anchor(state["resicze_anchor"])
    self.set_viewport_update_mode(state["viewport_update_mode"])
    self.set_drag_mode(state["drag_mode"])
    self.set_rubberband_selection_mode(state["rubberband_selection_mode"])
    self.setSceneRect(state["scene_rect"])
    self.set_cache_mode(state["cache_mode"])
    self.setInteractive(state["is_interactive"])

get_background_brush() -> gui.Brush

Source code in prettyqt\widgets\graphicsview.py
def get_background_brush(self) -> gui.Brush:
    return gui.Brush(self.backgroundBrush())

get_cache_mode() -> CacheModeStr

Return current cache mode.

Returns:

Type Description
CacheModeStr

cache mode

Source code in prettyqt\widgets\graphicsview.py
def get_cache_mode(self) -> CacheModeStr:
    """Return current cache mode.

    Returns:
        cache mode
    """
    return CACHE_MODES.inverse[self.cacheMode()]

get_drag_mode() -> DragModeStr

Return current drag mode.

Returns:

Type Description
DragModeStr

drag mode

Source code in prettyqt\widgets\graphicsview.py
def get_drag_mode(self) -> DragModeStr:
    """Return current drag mode.

    Returns:
        drag mode
    """
    return DRAG_MODE.inverse[self.dragMode()]

get_foreground_brush() -> gui.Brush

Source code in prettyqt\widgets\graphicsview.py
def get_foreground_brush(self) -> gui.Brush:
    return gui.Brush(self.foregroundBrush())

get_optimization_flags() -> list[OptimizationFlagStr]

Source code in prettyqt\widgets\graphicsview.py
def get_optimization_flags(self) -> list[OptimizationFlagStr]:
    return OPTIMIZATION_FLAGS.get_list(self.optimizationFlags())

get_resize_anchor() -> ViewportAnchorStr

Return current resize anchor.

Returns:

Type Description
ViewportAnchorStr

resize anchor

Source code in prettyqt\widgets\graphicsview.py
def get_resize_anchor(self) -> ViewportAnchorStr:
    """Return current resize anchor.

    Returns:
        resize anchor
    """
    return VIEWPORT_ANCHOR.inverse[self.resizeAnchor()]

get_rubberband_selection_mode() -> constants.ItemSelectionModeStr

Return current rubberband selection mode.

Returns:

Type Description
constants.ItemSelectionModeStr

rubberband selection mode

Source code in prettyqt\widgets\graphicsview.py
def get_rubberband_selection_mode(self) -> constants.ItemSelectionModeStr:
    """Return current rubberband selection mode.

    Returns:
        rubberband selection mode
    """
    return constants.ITEM_SELECTION_MODE.inverse[self.rubberBandSelectionMode()]

get_transformation_anchor() -> ViewportAnchorStr

Return current transformation anchor.

Returns:

Type Description
ViewportAnchorStr

viewport anchor

Source code in prettyqt\widgets\graphicsview.py
def get_transformation_anchor(self) -> ViewportAnchorStr:
    """Return current transformation anchor.

    Returns:
        viewport anchor
    """
    return VIEWPORT_ANCHOR.inverse[self.transformationAnchor()]

get_viewport_update_mode() -> ViewportUpdateModeStr

Return current viewport update mode.

Returns:

Type Description
ViewportUpdateModeStr

viewport update mode

Source code in prettyqt\widgets\graphicsview.py
def get_viewport_update_mode(self) -> ViewportUpdateModeStr:
    """Return current viewport update mode.

    Returns:
        viewport update mode
    """
    return VIEWPORT_UPDATE_MODE.inverse[self.viewportUpdateMode()]

invalidate_scene(rect: QtCore.QRectF, layer: widgets.graphicsscene.SceneLayerStr = 'all')

Source code in prettyqt\widgets\graphicsview.py
def invalidate_scene(
    self, rect: QtCore.QRectF, layer: widgets.graphicsscene.SceneLayerStr = "all"
):
    if layer not in widgets.graphicsscene.SCENE_LAYER:
        raise InvalidParamError(layer, widgets.graphicsscene.SCENE_LAYER)
    self.invalidateScene(rect, widgets.graphicsscene.SCENE_LAYER[layer])

serialize_fields()

Source code in prettyqt\widgets\graphicsview.py
def serialize_fields(self):
    return dict(
        scene=self.scene(),
        background_brush=self.get_background_brush(),
        foreground_brush=self.get_foreground_brush(),
        transformation_anchor=self.get_transformation_anchor(),
        resize_anchor=self.get_resize_anchor(),
        viewport_update_mode=self.get_viewport_update_mode(),
        drag_mode=self.get_drag_mode(),
        rubberband_selection_mode=self.get_rubberband_selection_mode(),
        scene_rect=core.RectF(self.sceneRect()),
        cache_mode=self.get_cache_mode(),
        is_interactive=self.isInteractive(),
    )

set_cache_mode(mode: CacheModeStr)

Set the cache mode.

Parameters:

Name Type Description Default
mode CacheModeStr

cache mode to use

required

Raises:

Type Description
InvalidParamError

mode does not exist

Source code in prettyqt\widgets\graphicsview.py
def set_cache_mode(self, mode: CacheModeStr):
    """Set the cache mode.

    Args:
        mode: cache mode to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode not in CACHE_MODES:
        raise InvalidParamError(mode, CACHE_MODES)
    self.setCacheMode(CACHE_MODES[mode])

set_drag_mode(mode: DragModeStr)

Set the behavior for dragging the mouse while the left mouse button is pressed.

Parameters:

Name Type Description Default
mode DragModeStr

drag mode to use

required

Raises:

Type Description
InvalidParamError

mode does not exist

Source code in prettyqt\widgets\graphicsview.py
def set_drag_mode(self, mode: DragModeStr):
    """Set the behavior for dragging the mouse while the left mouse button is pressed.

    Args:
        mode: drag mode to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode not in DRAG_MODE:
        raise InvalidParamError(mode, DRAG_MODE)
    self.setDragMode(DRAG_MODE[mode])

set_optimization_flags(*items: OptimizationFlagStr)

Source code in prettyqt\widgets\graphicsview.py
def set_optimization_flags(self, *items: OptimizationFlagStr):
    for item in items:
        if item not in OPTIMIZATION_FLAGS:
            raise InvalidParamError(item, OPTIMIZATION_FLAGS)
    flags = helpers.merge_flags(items, OPTIMIZATION_FLAGS)
    self.setOptimizationFlags(flags)

set_resize_anchor(mode: ViewportAnchorStr)

Set how the view should position the scene during resizes.

Parameters:

Name Type Description Default
mode ViewportAnchorStr

resize anchor to use

required

Raises:

Type Description
InvalidParamError

mode does not exist

Source code in prettyqt\widgets\graphicsview.py
def set_resize_anchor(self, mode: ViewportAnchorStr):
    """Set how the view should position the scene during resizes.

    Args:
        mode: resize anchor to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode not in VIEWPORT_ANCHOR:
        raise InvalidParamError(mode, VIEWPORT_ANCHOR)
    self.setResizeAnchor(VIEWPORT_ANCHOR[mode])

set_rubberband_selection_mode(mode: constants.ItemSelectionModeStr)

Set the behavior for selecting items with a rubber band selection rectangle.

Parameters:

Name Type Description Default
mode constants.ItemSelectionModeStr

rubberband selection mode to use

required

Raises:

Type Description
InvalidParamError

mode does not exist

Source code in prettyqt\widgets\graphicsview.py
def set_rubberband_selection_mode(self, mode: constants.ItemSelectionModeStr):
    """Set the behavior for selecting items with a rubber band selection rectangle.

    Args:
        mode: rubberband selection mode to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode not in constants.ITEM_SELECTION_MODE:
        raise InvalidParamError(mode, constants.ITEM_SELECTION_MODE)
    self.setRubberBandSelectionMode(constants.ITEM_SELECTION_MODE[mode])

set_transform(transform: datatypes.TransformType, combine: bool = False)

Source code in prettyqt\widgets\graphicsview.py
def set_transform(self, transform: datatypes.TransformType, combine: bool = False):
    if isinstance(transform, tuple):
        transform = gui.Transform(*transform)
    self.setTransform(transform, combine)

set_transformation_anchor(mode: ViewportAnchorStr)

Set how the view should position the scene during transformations.

Parameters:

Name Type Description Default
mode ViewportAnchorStr

transformation anchor to use

required

Raises:

Type Description
InvalidParamError

mode does not exist

Source code in prettyqt\widgets\graphicsview.py
def set_transformation_anchor(self, mode: ViewportAnchorStr):
    """Set how the view should position the scene during transformations.

    Args:
        mode: transformation anchor to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode not in VIEWPORT_ANCHOR:
        raise InvalidParamError(mode, VIEWPORT_ANCHOR)
    self.setTransformationAnchor(VIEWPORT_ANCHOR[mode])

set_viewport_update_mode(mode: ViewportUpdateModeStr)

Set how the viewport should update its contents.

Parameters:

Name Type Description Default
mode ViewportUpdateModeStr

viewport update mode to use

required

Raises:

Type Description
InvalidParamError

mode does not exist

Source code in prettyqt\widgets\graphicsview.py
def set_viewport_update_mode(self, mode: ViewportUpdateModeStr):
    """Set how the viewport should update its contents.

    Args:
        mode: viewport update mode to use

    Raises:
        InvalidParamError: mode does not exist
    """
    if mode not in VIEWPORT_UPDATE_MODE:
        raise InvalidParamError(mode, VIEWPORT_UPDATE_MODE)
    self.setViewportUpdateMode(VIEWPORT_UPDATE_MODE[mode])

GraphicsWidget

Bases: GraphicsWidgetMixin, QtWidgets.QGraphicsWidget

Source code in prettyqt\widgets\graphicswidget.py
class GraphicsWidget(GraphicsWidgetMixin, QtWidgets.QGraphicsWidget):
    pass

GraphicsWidgetMixin

Bases: widgets.GraphicsObjectMixin, widgets.GraphicsLayoutItemMixin

Source code in prettyqt\widgets\graphicswidget.py
class GraphicsWidgetMixin(widgets.GraphicsObjectMixin, widgets.GraphicsLayoutItemMixin):
    def set_layout(self, layout: LayoutStr | QtWidgets.QGraphicsLayout | None):
        match layout:
            case None:
                return
            case QtWidgets.QGraphicsLayout():
                self.box = layout
            case "grid":
                self.box = widgets.GraphicsGridLayout()
            case "anchor":
                self.box = widgets.GraphicsAnchorLayout()
            case "horizontal" | "vertical":
                self.box = widgets.GraphicsLinearLayout(layout)
            case _:
                raise ValueError("Invalid Layout")
        self.setLayout(self.box)

    def set_focus_policy(self, policy: constants.FocusPolicyStr) -> None:
        """Set the way the widget accepts keyboard focus.

        Args:
            policy: Focus policy

        Raises:
            InvalidParamError: Description
        """
        if policy not in constants.FOCUS_POLICY:
            raise InvalidParamError(policy, constants.FOCUS_POLICY)
        self.setFocusPolicy(constants.FOCUS_POLICY[policy])

    def get_focus_policy(self) -> constants.FocusPolicyStr:
        """Return way the widget accepts keyboard focus.

        Returns:
            str: Focus policy
        """
        return constants.FOCUS_POLICY.inverse[self.focusPolicy()]

    def window_frame_section_at(
        self, point: datatypes.PointType
    ) -> constants.WindowFrameSectionStr:
        """Return the window frame section at given position.

        Returns:
            str: Window frame section
        """
        if isinstance(point, tuple):
            point = QtCore.QPoint(*point)
        return constants.WINDOW_FRAME_SECTION.inverse[self.windowFrameSectionAt(point)]

    def get_font(self) -> gui.Font:
        return gui.Font(self.font())

    def get_palette(self) -> gui.Palette:
        return gui.Palette(self.palette())

get_focus_policy() -> constants.FocusPolicyStr

Return way the widget accepts keyboard focus.

Returns:

Name Type Description
str constants.FocusPolicyStr

Focus policy

Source code in prettyqt\widgets\graphicswidget.py
def get_focus_policy(self) -> constants.FocusPolicyStr:
    """Return way the widget accepts keyboard focus.

    Returns:
        str: Focus policy
    """
    return constants.FOCUS_POLICY.inverse[self.focusPolicy()]

get_font() -> gui.Font

Source code in prettyqt\widgets\graphicswidget.py
def get_font(self) -> gui.Font:
    return gui.Font(self.font())

get_palette() -> gui.Palette

Source code in prettyqt\widgets\graphicswidget.py
def get_palette(self) -> gui.Palette:
    return gui.Palette(self.palette())

set_focus_policy(policy: constants.FocusPolicyStr) -> None

Set the way the widget accepts keyboard focus.

Parameters:

Name Type Description Default
policy constants.FocusPolicyStr

Focus policy

required

Raises:

Type Description
InvalidParamError

Description

Source code in prettyqt\widgets\graphicswidget.py
def set_focus_policy(self, policy: constants.FocusPolicyStr) -> None:
    """Set the way the widget accepts keyboard focus.

    Args:
        policy: Focus policy

    Raises:
        InvalidParamError: Description
    """
    if policy not in constants.FOCUS_POLICY:
        raise InvalidParamError(policy, constants.FOCUS_POLICY)
    self.setFocusPolicy(constants.FOCUS_POLICY[policy])

set_layout(layout: LayoutStr | QtWidgets.QGraphicsLayout | None)

Source code in prettyqt\widgets\graphicswidget.py
def set_layout(self, layout: LayoutStr | QtWidgets.QGraphicsLayout | None):
    match layout:
        case None:
            return
        case QtWidgets.QGraphicsLayout():
            self.box = layout
        case "grid":
            self.box = widgets.GraphicsGridLayout()
        case "anchor":
            self.box = widgets.GraphicsAnchorLayout()
        case "horizontal" | "vertical":
            self.box = widgets.GraphicsLinearLayout(layout)
        case _:
            raise ValueError("Invalid Layout")
    self.setLayout(self.box)

window_frame_section_at(point: datatypes.PointType) -> constants.WindowFrameSectionStr

Return the window frame section at given position.

Returns:

Name Type Description
str constants.WindowFrameSectionStr

Window frame section

Source code in prettyqt\widgets\graphicswidget.py
def window_frame_section_at(
    self, point: datatypes.PointType
) -> constants.WindowFrameSectionStr:
    """Return the window frame section at given position.

    Returns:
        str: Window frame section
    """
    if isinstance(point, tuple):
        point = QtCore.QPoint(*point)
    return constants.WINDOW_FRAME_SECTION.inverse[self.windowFrameSectionAt(point)]

GridLayout

Bases: widgets.LayoutMixin, QtWidgets.QGridLayout

Source code in prettyqt\widgets\gridlayout.py
class GridLayout(widgets.LayoutMixin, QtWidgets.QGridLayout):
    def __getitem__(
        self, idx: tuple[int, int] | int | str
    ) -> QtWidgets.QWidget | QtWidgets.QLayout | None:
        if isinstance(idx, tuple):
            item = self.itemAtPosition(*idx)
        elif isinstance(idx, int):
            item = self.itemAt(idx)
        else:
            return self.find_child(QtCore.QObject, idx)
        widget = item.widget()
        return item.layout() if widget is None else widget

    def __setitem__(
        self,
        idx: tuple[int | slice, int | slice],
        value: QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem,
    ):
        row, col = idx
        rowspan = row.stop - row.start + 1 if isinstance(row, slice) else 1
        colspan = col.stop - col.start + 1 if isinstance(col, slice) else 1
        rowstart = row.start if isinstance(row, slice) else row
        colstart = col.start if isinstance(col, slice) else col
        self.add(value, rowstart, colstart, rowspan, colspan)

    # def serialize_fields(self):
    #     widgets = []
    #     positions = []
    #     for i, item in enumerate(list(self)):
    #         widgets.append(item)
    #         positions.append(self.getItemPosition(i))
    #     return dict(widgets=widgets, positions=positions)

    # def __setstate__(self, state):
    #     for item, pos in zip(state["widgets"], state["positions"]):
    #         x, y, w, h = pos
    #         self[x : x + w - 1, y : y + h - 1] = item

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    def __iter__(self) -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout]:
        return iter(item for i in range(self.count()) if (item := self[i]) is not None)

    def __add__(
        self,
        other: (
            tuple | list | QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem
        ),
    ):
        if isinstance(other, tuple | list):
            for i, _control in enumerate(other):
                self[self.rowCount(), i] = other  # type: ignore
        else:
            self[self.rowCount(), 0 : self.columnCount() - 1] = other
        return self

    def add(
        self,
        item: QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem,
        rowstart: int,
        colstart: int,
        rowspan: int = 1,
        colspan: int = 1,
    ):
        match item:
            case QtWidgets.QWidget():
                self.addWidget(item, rowstart, colstart, rowspan, colspan)
            case QtWidgets.QLayout():
                self.addLayout(item, rowstart, colstart, rowspan, colspan)
            case QtWidgets.QLayoutItem():
                self.addItem(item, rowstart, colstart, rowspan, colspan)

    def append(self, item: QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem):
        self[self.rowCount(), 0 : self.columnCount() - 1] = item

    def set_origin_corner(self, corner: constants.CornerStr):
        """Set the origin corner.

        Args:
            corner: origin corner

        Raises:
            InvalidParamError: corner does not exist
        """
        if corner not in constants.CORNER:
            raise InvalidParamError(corner, constants.CORNER)
        self.setOriginCorner(constants.CORNER[corner])

    def get_origin_corner(self) -> constants.CornerStr:
        """Return current origin corner.

        Returns:
            origin corner
        """
        return constants.CORNER.inverse[self.originCorner()]

__add__(other: tuple | list | QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem)

Source code in prettyqt\widgets\gridlayout.py
def __add__(
    self,
    other: (
        tuple | list | QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem
    ),
):
    if isinstance(other, tuple | list):
        for i, _control in enumerate(other):
            self[self.rowCount(), i] = other  # type: ignore
    else:
        self[self.rowCount(), 0 : self.columnCount() - 1] = other
    return self

__getitem__(idx: tuple[int, int] | int | str) -> QtWidgets.QWidget | QtWidgets.QLayout | None

Source code in prettyqt\widgets\gridlayout.py
def __getitem__(
    self, idx: tuple[int, int] | int | str
) -> QtWidgets.QWidget | QtWidgets.QLayout | None:
    if isinstance(idx, tuple):
        item = self.itemAtPosition(*idx)
    elif isinstance(idx, int):
        item = self.itemAt(idx)
    else:
        return self.find_child(QtCore.QObject, idx)
    widget = item.widget()
    return item.layout() if widget is None else widget

__iter__() -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout]

Source code in prettyqt\widgets\gridlayout.py
def __iter__(self) -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout]:
    return iter(item for i in range(self.count()) if (item := self[i]) is not None)

__setitem__(idx: tuple[int | slice, int | slice], value: QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem)

Source code in prettyqt\widgets\gridlayout.py
def __setitem__(
    self,
    idx: tuple[int | slice, int | slice],
    value: QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem,
):
    row, col = idx
    rowspan = row.stop - row.start + 1 if isinstance(row, slice) else 1
    colspan = col.stop - col.start + 1 if isinstance(col, slice) else 1
    rowstart = row.start if isinstance(row, slice) else row
    colstart = col.start if isinstance(col, slice) else col
    self.add(value, rowstart, colstart, rowspan, colspan)

add(item: QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem, rowstart: int, colstart: int, rowspan: int = 1, colspan: int = 1)

Source code in prettyqt\widgets\gridlayout.py
def add(
    self,
    item: QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem,
    rowstart: int,
    colstart: int,
    rowspan: int = 1,
    colspan: int = 1,
):
    match item:
        case QtWidgets.QWidget():
            self.addWidget(item, rowstart, colstart, rowspan, colspan)
        case QtWidgets.QLayout():
            self.addLayout(item, rowstart, colstart, rowspan, colspan)
        case QtWidgets.QLayoutItem():
            self.addItem(item, rowstart, colstart, rowspan, colspan)

append(item: QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem)

Source code in prettyqt\widgets\gridlayout.py
def append(self, item: QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QLayoutItem):
    self[self.rowCount(), 0 : self.columnCount() - 1] = item

get_origin_corner() -> constants.CornerStr

Return current origin corner.

Returns:

Type Description
constants.CornerStr

origin corner

Source code in prettyqt\widgets\gridlayout.py
def get_origin_corner(self) -> constants.CornerStr:
    """Return current origin corner.

    Returns:
        origin corner
    """
    return constants.CORNER.inverse[self.originCorner()]

set_origin_corner(corner: constants.CornerStr)

Set the origin corner.

Parameters:

Name Type Description Default
corner constants.CornerStr

origin corner

required

Raises:

Type Description
InvalidParamError

corner does not exist

Source code in prettyqt\widgets\gridlayout.py
def set_origin_corner(self, corner: constants.CornerStr):
    """Set the origin corner.

    Args:
        corner: origin corner

    Raises:
        InvalidParamError: corner does not exist
    """
    if corner not in constants.CORNER:
        raise InvalidParamError(corner, constants.CORNER)
    self.setOriginCorner(constants.CORNER[corner])

GroupBox

Bases: widgets.WidgetMixin, QtWidgets.QGroupBox

GroupBox widget.

A group box provides a frame, a title on top, a keyboard shortcut, and displays various other widgets inside itself. The keyboard shortcut moves keyboard focus to one of the group box's child widgets.

Source code in prettyqt\widgets\groupbox.py
class GroupBox(widgets.WidgetMixin, QtWidgets.QGroupBox):
    """GroupBox widget.

    A group box provides a frame, a title on top, a keyboard shortcut,
    and displays various other widgets inside itself.
    The keyboard shortcut moves keyboard focus to one of the group box's child widgets.
    """

    def __init__(
        self,
        title: str = "",
        checkable: bool = False,
        parent: QtWidgets.QWidget | None = None,
    ):
        super().__init__(title, parent)
        self.setCheckable(checkable)

    def __repr__(self):
        return get_repr(self, self.title())

    def set_title(self, title: str):
        self.setTitle(title)

    def set_alignment(self, alignment):
        self.setAlignment(constants.H_ALIGNMENT[alignment])

    def set_enabled(self, state):
        for widget in self.layout():
            widget.setEnabled(state)

__init__(title: str = '', checkable: bool = False, parent: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\groupbox.py
def __init__(
    self,
    title: str = "",
    checkable: bool = False,
    parent: QtWidgets.QWidget | None = None,
):
    super().__init__(title, parent)
    self.setCheckable(checkable)

__repr__()

Source code in prettyqt\widgets\groupbox.py
def __repr__(self):
    return get_repr(self, self.title())

set_alignment(alignment)

Source code in prettyqt\widgets\groupbox.py
def set_alignment(self, alignment):
    self.setAlignment(constants.H_ALIGNMENT[alignment])

set_enabled(state)

Source code in prettyqt\widgets\groupbox.py
def set_enabled(self, state):
    for widget in self.layout():
        widget.setEnabled(state)

set_title(title: str)

Source code in prettyqt\widgets\groupbox.py
def set_title(self, title: str):
    self.setTitle(title)

HeaderView

Bases: HeaderViewMixin, QtWidgets.QHeaderView

Source code in prettyqt\widgets\headerview.py
class HeaderView(HeaderViewMixin, QtWidgets.QHeaderView):
    pass

InputDialog

Bases: widgets.DialogMixin, QtWidgets.QInputDialog

Source code in prettyqt\widgets\inputdialog.py
class InputDialog(widgets.DialogMixin, QtWidgets.QInputDialog):
    @classmethod
    def get_int(
        cls,
        title: str = "",
        label: str = "",
        icon: datatypes.IconType = None,
    ) -> int | None:
        par = widgets.Dialog()
        par.set_icon(icon)
        v = cls.getInt(par, title, label, value=0)
        return v[0] if v[1] else None

    @classmethod
    def get_float(
        cls,
        title: str = "",
        label: str = "",
        icon: datatypes.IconType = None,
    ) -> float | None:
        par = widgets.Dialog()
        par.set_icon(icon)
        v = cls.getDouble(par, title, label, value=0.0)
        return v[0] if v[1] else None

    @classmethod
    def get_text(
        cls,
        title: str = "",
        label: str = "",
        icon: datatypes.IconType = None,
        default_value: str = "",
        echo_mode: widgets.lineedit.EchoModeStr = "normal",
    ) -> str | None:
        par = widgets.Dialog()
        par.set_icon(icon)
        if echo_mode not in widgets.lineedit.ECHO_MODE:
            raise InvalidParamError(echo_mode, widgets.lineedit.ECHO_MODE)
        v = cls.getText(
            par, title, label, widgets.lineedit.ECHO_MODE[echo_mode], default_value
        )
        return v[0] if v[1] else None

    @classmethod
    def get_item(
        cls,
        items: list[str],
        title: str = "",
        label: str = "",
        icon: datatypes.IconType = None,
        editable: bool = False,
    ) -> str | None:
        par = widgets.Dialog()
        par.set_icon(icon)
        v = cls.getItem(par, title, label, items, editable=editable, current=0)
        return v[0] if v[1] else None

    def set_text_echo_mode(self, mode: widgets.lineedit.EchoModeStr):
        """Set text echo mode.

        Args:
            mode: echo mode to use

        Raises:
            InvalidParamError: invalid echo mode
        """
        if mode not in widgets.lineedit.ECHO_MODE:
            raise InvalidParamError(mode, widgets.lineedit.ECHO_MODE)
        self.setTextEchoMode(widgets.lineedit.ECHO_MODE[mode])

    def get_text_echo_mode(self) -> widgets.lineedit.EchoModeStr:
        """Return text echo mode.

        Returns:
            echo mode
        """
        return widgets.lineedit.ECHO_MODE.inverse[self.textEchoMode()]

    def set_input_mode(self, mode: InputModeStr):
        """Set input mode.

        Args:
            mode: input mode to use

        Raises:
            InvalidParamError: invalid input mode
        """
        if mode not in INPUT_MODE:
            raise InvalidParamError(mode, INPUT_MODE)
        self.setInputMode(INPUT_MODE[mode])

    def get_input_mode(self) -> InputModeStr:
        """Return input mode.

        Returns:
            input mode
        """
        return INPUT_MODE.inverse[self.inputMode()]

get_float(title: str = '', label: str = '', icon: datatypes.IconType = None) -> float | None classmethod

Source code in prettyqt\widgets\inputdialog.py
@classmethod
def get_float(
    cls,
    title: str = "",
    label: str = "",
    icon: datatypes.IconType = None,
) -> float | None:
    par = widgets.Dialog()
    par.set_icon(icon)
    v = cls.getDouble(par, title, label, value=0.0)
    return v[0] if v[1] else None

get_input_mode() -> InputModeStr

Return input mode.

Returns:

Type Description
InputModeStr

input mode

Source code in prettyqt\widgets\inputdialog.py
def get_input_mode(self) -> InputModeStr:
    """Return input mode.

    Returns:
        input mode
    """
    return INPUT_MODE.inverse[self.inputMode()]

get_int(title: str = '', label: str = '', icon: datatypes.IconType = None) -> int | None classmethod

Source code in prettyqt\widgets\inputdialog.py
@classmethod
def get_int(
    cls,
    title: str = "",
    label: str = "",
    icon: datatypes.IconType = None,
) -> int | None:
    par = widgets.Dialog()
    par.set_icon(icon)
    v = cls.getInt(par, title, label, value=0)
    return v[0] if v[1] else None

get_item(items: list[str], title: str = '', label: str = '', icon: datatypes.IconType = None, editable: bool = False) -> str | None classmethod

Source code in prettyqt\widgets\inputdialog.py
@classmethod
def get_item(
    cls,
    items: list[str],
    title: str = "",
    label: str = "",
    icon: datatypes.IconType = None,
    editable: bool = False,
) -> str | None:
    par = widgets.Dialog()
    par.set_icon(icon)
    v = cls.getItem(par, title, label, items, editable=editable, current=0)
    return v[0] if v[1] else None

get_text(title: str = '', label: str = '', icon: datatypes.IconType = None, default_value: str = '', echo_mode: widgets.lineedit.EchoModeStr = 'normal') -> str | None classmethod

Source code in prettyqt\widgets\inputdialog.py
@classmethod
def get_text(
    cls,
    title: str = "",
    label: str = "",
    icon: datatypes.IconType = None,
    default_value: str = "",
    echo_mode: widgets.lineedit.EchoModeStr = "normal",
) -> str | None:
    par = widgets.Dialog()
    par.set_icon(icon)
    if echo_mode not in widgets.lineedit.ECHO_MODE:
        raise InvalidParamError(echo_mode, widgets.lineedit.ECHO_MODE)
    v = cls.getText(
        par, title, label, widgets.lineedit.ECHO_MODE[echo_mode], default_value
    )
    return v[0] if v[1] else None

get_text_echo_mode() -> widgets.lineedit.EchoModeStr

Return text echo mode.

Returns:

Type Description
widgets.lineedit.EchoModeStr

echo mode

Source code in prettyqt\widgets\inputdialog.py
def get_text_echo_mode(self) -> widgets.lineedit.EchoModeStr:
    """Return text echo mode.

    Returns:
        echo mode
    """
    return widgets.lineedit.ECHO_MODE.inverse[self.textEchoMode()]

set_input_mode(mode: InputModeStr)

Set input mode.

Parameters:

Name Type Description Default
mode InputModeStr

input mode to use

required

Raises:

Type Description
InvalidParamError

invalid input mode

Source code in prettyqt\widgets\inputdialog.py
def set_input_mode(self, mode: InputModeStr):
    """Set input mode.

    Args:
        mode: input mode to use

    Raises:
        InvalidParamError: invalid input mode
    """
    if mode not in INPUT_MODE:
        raise InvalidParamError(mode, INPUT_MODE)
    self.setInputMode(INPUT_MODE[mode])

set_text_echo_mode(mode: widgets.lineedit.EchoModeStr)

Set text echo mode.

Parameters:

Name Type Description Default
mode widgets.lineedit.EchoModeStr

echo mode to use

required

Raises:

Type Description
InvalidParamError

invalid echo mode

Source code in prettyqt\widgets\inputdialog.py
def set_text_echo_mode(self, mode: widgets.lineedit.EchoModeStr):
    """Set text echo mode.

    Args:
        mode: echo mode to use

    Raises:
        InvalidParamError: invalid echo mode
    """
    if mode not in widgets.lineedit.ECHO_MODE:
        raise InvalidParamError(mode, widgets.lineedit.ECHO_MODE)
    self.setTextEchoMode(widgets.lineedit.ECHO_MODE[mode])

ItemDelegate

Bases: widgets.AbstractItemDelegateMixin, QtWidgets.QItemDelegate

Source code in prettyqt\widgets\itemdelegate.py
class ItemDelegate(widgets.AbstractItemDelegateMixin, QtWidgets.QItemDelegate):
    pass

ItemEditorCreatorBase

Bases: QtWidgets.QItemEditorCreatorBase

Source code in prettyqt\widgets\itemeditorcreatorbase.py
class ItemEditorCreatorBase(QtWidgets.QItemEditorCreatorBase):
    pass

ItemEditorFactory

Bases: QtWidgets.QItemEditorFactory

Source code in prettyqt\widgets\itemeditorfactory.py
class ItemEditorFactory(QtWidgets.QItemEditorFactory):
    @classmethod
    def register_default_editor(
        cls, editor_cls: type[QtWidgets.QWidget], typ: int | None = None
    ):
        factory = cls.defaultFactory()
        factory.register_editor(editor_cls, typ)
        cls.setDefaultFactory(factory)

    def register_editor(
        self,
        editor_cls: type[QtWidgets.QWidget],
        typ: int | None = None,
        property_name: str = "",
    ):
        class EditorCreator(widgets.ItemEditorCreatorBase):
            def createWidget(self, parent: QtWidgets.QWidget) -> QtWidgets.QWidget:
                return editor_cls(parent=parent)

            def valuePropertyName(self) -> QtCore.QByteArray:
                return QtCore.QByteArray(property_name.encode())

        if typ is None:
            typ = editor_cls.staticMetaObject.userProperty().userType()
        self.registerEditor(typ, EditorCreator())

register_default_editor(editor_cls: type[QtWidgets.QWidget], typ: int | None = None) classmethod

Source code in prettyqt\widgets\itemeditorfactory.py
@classmethod
def register_default_editor(
    cls, editor_cls: type[QtWidgets.QWidget], typ: int | None = None
):
    factory = cls.defaultFactory()
    factory.register_editor(editor_cls, typ)
    cls.setDefaultFactory(factory)

register_editor(editor_cls: type[QtWidgets.QWidget], typ: int | None = None, property_name: str = '')

Source code in prettyqt\widgets\itemeditorfactory.py
def register_editor(
    self,
    editor_cls: type[QtWidgets.QWidget],
    typ: int | None = None,
    property_name: str = "",
):
    class EditorCreator(widgets.ItemEditorCreatorBase):
        def createWidget(self, parent: QtWidgets.QWidget) -> QtWidgets.QWidget:
            return editor_cls(parent=parent)

        def valuePropertyName(self) -> QtCore.QByteArray:
            return QtCore.QByteArray(property_name.encode())

    if typ is None:
        typ = editor_cls.staticMetaObject.userProperty().userType()
    self.registerEditor(typ, EditorCreator())

KeySequenceEdit

Bases: widgets.WidgetMixin, QtWidgets.QKeySequenceEdit

Source code in prettyqt\widgets\keysequenceedit.py
class KeySequenceEdit(widgets.WidgetMixin, QtWidgets.QKeySequenceEdit):
    value_changed = core.Signal(QtGui.QKeySequence)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.keySequenceChanged.connect(self.value_changed)

    def __repr__(self):
        return get_repr(self, self.get_value())

    def set_value(self, value: str):
        seq = gui.KeySequence.fromString(value)
        self.setKeySequence(seq)

    def get_value(self) -> str:
        return self.keySequence().toString()

    def is_valid(self) -> bool:
        return True

value_changed = core.Signal(QtGui.QKeySequence) class-attribute

__init__(*args, **kwargs)

Source code in prettyqt\widgets\keysequenceedit.py
def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.keySequenceChanged.connect(self.value_changed)

__repr__()

Source code in prettyqt\widgets\keysequenceedit.py
def __repr__(self):
    return get_repr(self, self.get_value())

get_value() -> str

Source code in prettyqt\widgets\keysequenceedit.py
def get_value(self) -> str:
    return self.keySequence().toString()

is_valid() -> bool

Source code in prettyqt\widgets\keysequenceedit.py
def is_valid(self) -> bool:
    return True

set_value(value: str)

Source code in prettyqt\widgets\keysequenceedit.py
def set_value(self, value: str):
    seq = gui.KeySequence.fromString(value)
    self.setKeySequence(seq)

LCDNumber

Bases: widgets.FrameMixin, QtWidgets.QLCDNumber

Source code in prettyqt\widgets\lcdnumber.py
class LCDNumber(widgets.FrameMixin, QtWidgets.QLCDNumber):
    def set_mode(self, mode: ModeStr):
        """Set the lcd mode.

        Args:
            mode: lcd mode to use

        Raises:
            InvalidParamError: lcd mode does not exist
        """
        if mode not in MODE:
            raise InvalidParamError(mode, MODE)
        self.setMode(MODE[mode])

    def get_mode(self) -> ModeStr:
        """Return current lcd mode.

        Returns:
            lcd mode
        """
        return MODE.inverse[self.mode()]

    def set_segment_style(self, mode: SegmentStyleStr):
        """Set the segment style.

        Args:
            mode: segment style to use

        Raises:
            InvalidParamError: segment style does not exist
        """
        if mode not in SEGMENT_STYLE:
            raise InvalidParamError(mode, SEGMENT_STYLE)
        self.setSegmentStyle(SEGMENT_STYLE[mode])

    def get_segment_style(self) -> SegmentStyleStr:
        """Return current segment style.

        Returns:
            segment style
        """
        return SEGMENT_STYLE.inverse[self.segmentStyle()]

    def set_value(self, value: float | str):
        self.display(value)

    def get_value(self) -> float:
        return self.value()

get_mode() -> ModeStr

Return current lcd mode.

Returns:

Type Description
ModeStr

lcd mode

Source code in prettyqt\widgets\lcdnumber.py
def get_mode(self) -> ModeStr:
    """Return current lcd mode.

    Returns:
        lcd mode
    """
    return MODE.inverse[self.mode()]

get_segment_style() -> SegmentStyleStr

Return current segment style.

Returns:

Type Description
SegmentStyleStr

segment style

Source code in prettyqt\widgets\lcdnumber.py
def get_segment_style(self) -> SegmentStyleStr:
    """Return current segment style.

    Returns:
        segment style
    """
    return SEGMENT_STYLE.inverse[self.segmentStyle()]

get_value() -> float

Source code in prettyqt\widgets\lcdnumber.py
def get_value(self) -> float:
    return self.value()

set_mode(mode: ModeStr)

Set the lcd mode.

Parameters:

Name Type Description Default
mode ModeStr

lcd mode to use

required

Raises:

Type Description
InvalidParamError

lcd mode does not exist

Source code in prettyqt\widgets\lcdnumber.py
def set_mode(self, mode: ModeStr):
    """Set the lcd mode.

    Args:
        mode: lcd mode to use

    Raises:
        InvalidParamError: lcd mode does not exist
    """
    if mode not in MODE:
        raise InvalidParamError(mode, MODE)
    self.setMode(MODE[mode])

set_segment_style(mode: SegmentStyleStr)

Set the segment style.

Parameters:

Name Type Description Default
mode SegmentStyleStr

segment style to use

required

Raises:

Type Description
InvalidParamError

segment style does not exist

Source code in prettyqt\widgets\lcdnumber.py
def set_segment_style(self, mode: SegmentStyleStr):
    """Set the segment style.

    Args:
        mode: segment style to use

    Raises:
        InvalidParamError: segment style does not exist
    """
    if mode not in SEGMENT_STYLE:
        raise InvalidParamError(mode, SEGMENT_STYLE)
    self.setSegmentStyle(SEGMENT_STYLE[mode])

set_value(value: float | str)

Source code in prettyqt\widgets\lcdnumber.py
def set_value(self, value: float | str):
    self.display(value)

Label

Bases: widgets.FrameMixin, QtWidgets.QLabel

Source code in prettyqt\widgets\label.py
class Label(widgets.FrameMixin, QtWidgets.QLabel):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.openExternalLinks()

    def __repr__(self):
        return get_repr(self, self.text())

    def allow_links(self) -> Label:
        # self.setText("<a href=\"http://example.com/\">Click Here!</a>")
        self.setTextFormat(QtCore.Qt.TextFormat.RichText)
        self.setTextInteractionFlags(
            QtCore.Qt.TextInteractionFlag.TextBrowserInteraction  # type: ignore
        )
        self.setOpenExternalLinks(True)
        return self

    def set_alignment(
        self,
        horizontal: constants.HorizontalAlignmentStr | None = None,
        vertical: constants.VerticalAlignmentStr | None = None,
    ):
        """Set the alignment of the label's contents."""
        match horizontal, vertical:
            case None, None:
                return self
            case None, _:
                flag = constants.V_ALIGNMENT[vertical]
            case _, None:
                flag = constants.H_ALIGNMENT[horizontal]
            case _, _:
                flag = constants.V_ALIGNMENT[vertical] | constants.H_ALIGNMENT[horizontal]
        self.setAlignment(flag)
        return self

    def get_horizontal_alignment(self) -> constants.HorizontalAlignmentStr:
        align = self.alignment()
        if align & constants.ALIGN_RIGHT:  # type: ignore
            return "right"
        elif align & constants.ALIGN_H_CENTER:  # type: ignore
            return "center"
        elif align & constants.ALIGN_JUSTIFY:  # type: ignore
            return "justify"
        else:
            return "left"

    def get_vertical_alignment(self) -> constants.VerticalAlignmentStr:
        align = self.alignment()
        if align & constants.ALIGN_TOP:  # type: ignore
            return "top"
        elif align & constants.ALIGN_BOTTOM:  # type: ignore
            return "bottom"
        elif align & constants.ALIGN_BASELINE:  # type: ignore
            return "baseline"
        else:
            return "center"

    def set_indent(self, indent: int) -> Label:
        """Set the label's text indent in pixels."""
        self.setIndent(indent)
        return self

    def set_text_format(self, text_format: TextFormatStr) -> Label:
        """Set the text format.

        Args:
            text_format: text format to use

        Raises:
            InvalidParamError: text format does not exist
        """
        if text_format not in TEXT_FORMAT:
            raise InvalidParamError(text_format, TEXT_FORMAT)
        self.setTextFormat(TEXT_FORMAT[text_format])
        return self

    def get_text_format(self) -> TextFormatStr:
        """Return current text format.

        Returns:
            text format
        """
        return TEXT_FORMAT.inverse[self.textFormat()]

    def set_text_interaction(self, *types: TextInteractionStr) -> Label:
        """Set the text interaction mode.

        Args:
            types: text interaction mode to use

        Raises:
            InvalidParamError: text interaction mode does not exist
        """
        for item in types:
            if item not in TEXT_INTERACTION:
                raise InvalidParamError(item, TEXT_INTERACTION)
        flags = helpers.merge_flags(types, TEXT_INTERACTION)
        self.setTextInteractionFlags(flags)
        return self

    def get_text_interaction(self) -> list[TextInteractionStr]:
        """Return current text interaction mode.

        Returns:
            list of text interaction modes
        """
        return TEXT_INTERACTION.get_list(self.textInteractionFlags())

    def set_text(self, text: str) -> Label:
        """Set the label's text."""
        self.setText(text)
        return self

    def set_bold(self, bold: bool = True) -> Label:
        font = self.font()
        font.setBold(bold)
        self.setFont(font)
        return self

    def set_italic(self, italic: bool = True) -> Label:
        font = self.font()
        font.setItalic(italic)
        self.setFont(font)
        return self

    def set_point_size(self, size: int) -> Label:
        font = self.font()
        font.setPointSize(size)
        self.setFont(font)
        return self

    def set_weight(self, weight: gui.font.WeightStr) -> Label:
        """Set the font weight.

        Args:
            weight: font weight

        Raises:
            InvalidParamError: invalid font weight
        """
        if weight not in gui.font.WEIGHT:
            raise InvalidParamError(weight, gui.font.WEIGHT)
        font = self.font()
        font.setWeight(gui.font.WEIGHT[weight])
        self.setFont(font)
        return self

    def set_color(self, color: datatypes.ColorType) -> Label:
        with self.edit_stylesheet() as ss:
            if color is None:
                ss.color.setValue("")
            else:
                color = colors.get_color(color)
                ss.color.setValue(color.name())
        return self

    def set_image(self, path: datatypes.PathType, width: int = 300) -> Label:
        self.setScaledContents(True)
        self.set_alignment(horizontal="center")
        self.setText(
            "<html><head/><body><p>"
            f"<img src={os.fspath(path)!r} width={str(width)!r}/>"
            "</p></body></html>"
        )
        return self

    @classmethod
    def image_from_path(
        cls, path: datatypes.PathType, parent: QtWidgets.QWidget | None = None
    ) -> Label:
        pixmap = gui.Pixmap.from_file(path)
        label = cls(parent=parent)
        label.setPixmap(pixmap)
        label.resize(pixmap.width(), pixmap.height())
        return label

__init__(*args, **kwargs)

Source code in prettyqt\widgets\label.py
def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.openExternalLinks()

__repr__()

Source code in prettyqt\widgets\label.py
def __repr__(self):
    return get_repr(self, self.text())
Source code in prettyqt\widgets\label.py
def allow_links(self) -> Label:
    # self.setText("<a href=\"http://example.com/\">Click Here!</a>")
    self.setTextFormat(QtCore.Qt.TextFormat.RichText)
    self.setTextInteractionFlags(
        QtCore.Qt.TextInteractionFlag.TextBrowserInteraction  # type: ignore
    )
    self.setOpenExternalLinks(True)
    return self

get_horizontal_alignment() -> constants.HorizontalAlignmentStr

Source code in prettyqt\widgets\label.py
def get_horizontal_alignment(self) -> constants.HorizontalAlignmentStr:
    align = self.alignment()
    if align & constants.ALIGN_RIGHT:  # type: ignore
        return "right"
    elif align & constants.ALIGN_H_CENTER:  # type: ignore
        return "center"
    elif align & constants.ALIGN_JUSTIFY:  # type: ignore
        return "justify"
    else:
        return "left"

get_text_format() -> TextFormatStr

Return current text format.

Returns:

Type Description
TextFormatStr

text format

Source code in prettyqt\widgets\label.py
def get_text_format(self) -> TextFormatStr:
    """Return current text format.

    Returns:
        text format
    """
    return TEXT_FORMAT.inverse[self.textFormat()]

get_text_interaction() -> list[TextInteractionStr]

Return current text interaction mode.

Returns:

Type Description
list[TextInteractionStr]

list of text interaction modes

Source code in prettyqt\widgets\label.py
def get_text_interaction(self) -> list[TextInteractionStr]:
    """Return current text interaction mode.

    Returns:
        list of text interaction modes
    """
    return TEXT_INTERACTION.get_list(self.textInteractionFlags())

get_vertical_alignment() -> constants.VerticalAlignmentStr

Source code in prettyqt\widgets\label.py
def get_vertical_alignment(self) -> constants.VerticalAlignmentStr:
    align = self.alignment()
    if align & constants.ALIGN_TOP:  # type: ignore
        return "top"
    elif align & constants.ALIGN_BOTTOM:  # type: ignore
        return "bottom"
    elif align & constants.ALIGN_BASELINE:  # type: ignore
        return "baseline"
    else:
        return "center"

image_from_path(path: datatypes.PathType, parent: QtWidgets.QWidget | None = None) -> Label classmethod

Source code in prettyqt\widgets\label.py
@classmethod
def image_from_path(
    cls, path: datatypes.PathType, parent: QtWidgets.QWidget | None = None
) -> Label:
    pixmap = gui.Pixmap.from_file(path)
    label = cls(parent=parent)
    label.setPixmap(pixmap)
    label.resize(pixmap.width(), pixmap.height())
    return label

set_alignment(horizontal: constants.HorizontalAlignmentStr | None = None, vertical: constants.VerticalAlignmentStr | None = None)

Set the alignment of the label's contents.

Source code in prettyqt\widgets\label.py
def set_alignment(
    self,
    horizontal: constants.HorizontalAlignmentStr | None = None,
    vertical: constants.VerticalAlignmentStr | None = None,
):
    """Set the alignment of the label's contents."""
    match horizontal, vertical:
        case None, None:
            return self
        case None, _:
            flag = constants.V_ALIGNMENT[vertical]
        case _, None:
            flag = constants.H_ALIGNMENT[horizontal]
        case _, _:
            flag = constants.V_ALIGNMENT[vertical] | constants.H_ALIGNMENT[horizontal]
    self.setAlignment(flag)
    return self

set_bold(bold: bool = True) -> Label

Source code in prettyqt\widgets\label.py
def set_bold(self, bold: bool = True) -> Label:
    font = self.font()
    font.setBold(bold)
    self.setFont(font)
    return self

set_color(color: datatypes.ColorType) -> Label

Source code in prettyqt\widgets\label.py
def set_color(self, color: datatypes.ColorType) -> Label:
    with self.edit_stylesheet() as ss:
        if color is None:
            ss.color.setValue("")
        else:
            color = colors.get_color(color)
            ss.color.setValue(color.name())
    return self

set_image(path: datatypes.PathType, width: int = 300) -> Label

Source code in prettyqt\widgets\label.py
def set_image(self, path: datatypes.PathType, width: int = 300) -> Label:
    self.setScaledContents(True)
    self.set_alignment(horizontal="center")
    self.setText(
        "<html><head/><body><p>"
        f"<img src={os.fspath(path)!r} width={str(width)!r}/>"
        "</p></body></html>"
    )
    return self

set_indent(indent: int) -> Label

Set the label's text indent in pixels.

Source code in prettyqt\widgets\label.py
def set_indent(self, indent: int) -> Label:
    """Set the label's text indent in pixels."""
    self.setIndent(indent)
    return self

set_italic(italic: bool = True) -> Label

Source code in prettyqt\widgets\label.py
def set_italic(self, italic: bool = True) -> Label:
    font = self.font()
    font.setItalic(italic)
    self.setFont(font)
    return self

set_point_size(size: int) -> Label

Source code in prettyqt\widgets\label.py
def set_point_size(self, size: int) -> Label:
    font = self.font()
    font.setPointSize(size)
    self.setFont(font)
    return self

set_text(text: str) -> Label

Set the label's text.

Source code in prettyqt\widgets\label.py
def set_text(self, text: str) -> Label:
    """Set the label's text."""
    self.setText(text)
    return self

set_text_format(text_format: TextFormatStr) -> Label

Set the text format.

Parameters:

Name Type Description Default
text_format TextFormatStr

text format to use

required

Raises:

Type Description
InvalidParamError

text format does not exist

Source code in prettyqt\widgets\label.py
def set_text_format(self, text_format: TextFormatStr) -> Label:
    """Set the text format.

    Args:
        text_format: text format to use

    Raises:
        InvalidParamError: text format does not exist
    """
    if text_format not in TEXT_FORMAT:
        raise InvalidParamError(text_format, TEXT_FORMAT)
    self.setTextFormat(TEXT_FORMAT[text_format])
    return self

set_text_interaction(*types: TextInteractionStr) -> Label

Set the text interaction mode.

Parameters:

Name Type Description Default
types TextInteractionStr

text interaction mode to use

()

Raises:

Type Description
InvalidParamError

text interaction mode does not exist

Source code in prettyqt\widgets\label.py
def set_text_interaction(self, *types: TextInteractionStr) -> Label:
    """Set the text interaction mode.

    Args:
        types: text interaction mode to use

    Raises:
        InvalidParamError: text interaction mode does not exist
    """
    for item in types:
        if item not in TEXT_INTERACTION:
            raise InvalidParamError(item, TEXT_INTERACTION)
    flags = helpers.merge_flags(types, TEXT_INTERACTION)
    self.setTextInteractionFlags(flags)
    return self

set_weight(weight: gui.font.WeightStr) -> Label

Set the font weight.

Parameters:

Name Type Description Default
weight gui.font.WeightStr

font weight

required

Raises:

Type Description
InvalidParamError

invalid font weight

Source code in prettyqt\widgets\label.py
def set_weight(self, weight: gui.font.WeightStr) -> Label:
    """Set the font weight.

    Args:
        weight: font weight

    Raises:
        InvalidParamError: invalid font weight
    """
    if weight not in gui.font.WEIGHT:
        raise InvalidParamError(weight, gui.font.WEIGHT)
    font = self.font()
    font.setWeight(gui.font.WEIGHT[weight])
    self.setFont(font)
    return self

Layout

Bases: LayoutMixin, QtWidgets.QLayout

Source code in prettyqt\widgets\layout.py
class Layout(LayoutMixin, QtWidgets.QLayout):
    pass

LayoutItem

Bases: LayoutItemMixin, QtWidgets.QLayoutItem

Source code in prettyqt\widgets\layoutitem.py
class LayoutItem(LayoutItemMixin, QtWidgets.QLayoutItem):
    pass

LayoutItemMixin

Source code in prettyqt\widgets\layoutitem.py
class LayoutItemMixin:
    def __bool__(self):
        return not self.isEmpty()

    def set_alignment(self, alignment: constants.AlignmentStr):
        """Set the alignment of the layout.

        Args:
            alignment: alignment for the layout

        Raises:
            InvalidParamError: alignment does not exist
        """
        if alignment not in constants.ALIGNMENTS:
            raise InvalidParamError(alignment, constants.ALIGNMENTS)
        self.setAlignment(constants.ALIGNMENTS[alignment])

    def get_alignment(self) -> constants.AlignmentStr:
        """Return current alignment.

        Returns:
            alignment
        """
        return constants.ALIGNMENTS.inverse[self.alignment()]

    def get_item(
        self,
    ) -> QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QSpacerItem | None:
        if content := self.widget():
            return content
        if content := self.layout():
            return content
        return content if (content := self.spacerItem()) else None

    def get_control_types(self) -> list[widgets.sizepolicy.ControlTypeStr]:
        return widgets.sizepolicy.CONTROL_TYPE.get_list(self.controlTypes())

    def get_expanding_directions(self) -> list[constants.OrientationStr]:
        return constants.ORIENTATION.get_list(self.expandingDirections())

__bool__()

Source code in prettyqt\widgets\layoutitem.py
def __bool__(self):
    return not self.isEmpty()

get_alignment() -> constants.AlignmentStr

Return current alignment.

Returns:

Type Description
constants.AlignmentStr

alignment

Source code in prettyqt\widgets\layoutitem.py
def get_alignment(self) -> constants.AlignmentStr:
    """Return current alignment.

    Returns:
        alignment
    """
    return constants.ALIGNMENTS.inverse[self.alignment()]

get_control_types() -> list[widgets.sizepolicy.ControlTypeStr]

Source code in prettyqt\widgets\layoutitem.py
def get_control_types(self) -> list[widgets.sizepolicy.ControlTypeStr]:
    return widgets.sizepolicy.CONTROL_TYPE.get_list(self.controlTypes())

get_expanding_directions() -> list[constants.OrientationStr]

Source code in prettyqt\widgets\layoutitem.py
def get_expanding_directions(self) -> list[constants.OrientationStr]:
    return constants.ORIENTATION.get_list(self.expandingDirections())

get_item() -> QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QSpacerItem | None

Source code in prettyqt\widgets\layoutitem.py
def get_item(
    self,
) -> QtWidgets.QWidget | QtWidgets.QLayout | QtWidgets.QSpacerItem | None:
    if content := self.widget():
        return content
    if content := self.layout():
        return content
    return content if (content := self.spacerItem()) else None

set_alignment(alignment: constants.AlignmentStr)

Set the alignment of the layout.

Parameters:

Name Type Description Default
alignment constants.AlignmentStr

alignment for the layout

required

Raises:

Type Description
InvalidParamError

alignment does not exist

Source code in prettyqt\widgets\layoutitem.py
def set_alignment(self, alignment: constants.AlignmentStr):
    """Set the alignment of the layout.

    Args:
        alignment: alignment for the layout

    Raises:
        InvalidParamError: alignment does not exist
    """
    if alignment not in constants.ALIGNMENTS:
        raise InvalidParamError(alignment, constants.ALIGNMENTS)
    self.setAlignment(constants.ALIGNMENTS[alignment])

LayoutMixin

Bases: core.ObjectMixin, widgets.LayoutItemMixin

Source code in prettyqt\widgets\layout.py
class LayoutMixin(core.ObjectMixin, widgets.LayoutItemMixin):
    def __getitem__(
        self, index: str | int
    ) -> QtWidgets.QWidget | QtWidgets.QLayout | None:
        if isinstance(index, int):
            item = self.itemAt(index)
            widget = item.widget()
            if widget is None:
                widget = item.layout()
        elif isinstance(index, str):
            return self.find_child(typ=QtCore.QObject, name=index)
        return widget

    def __delitem__(self, index: int):
        item = self.itemAt(index)
        self.removeItem(item)

    def __len__(self) -> int:
        return self.count()

    def __repr__(self):
        return get_repr(self)

    def __iter__(self) -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout | None]:
        return iter(self[i] for i in range(self.count()))

    def __contains__(self, item: QtWidgets.QWidget | QtWidgets.QLayoutItem):
        return self.indexOf(item) >= 0

    def serialize_fields(self):
        return dict(
            size_mode=self.get_size_mode(),
            spacing=self.spacing(),
            enabled=self.isEnabled(),
        )

    def get_children(self) -> list[QtWidgets.QWidget | QtWidgets.QLayout]:
        return list(self)

    def set_margin(self, margin: int):
        self.setContentsMargins(margin, margin, margin, margin)

    def set_spacing(self, pixels: int):
        self.setSpacing(pixels)

    @deprecated(reason="Use set_size_constraint instead")
    def set_size_mode(self, mode: SizeConstraintStr):
        self.set_size_constraint(mode)

    def set_size_constraint(self, mode: SizeConstraintStr):
        """Set the size mode of the layout.

        Args:
            mode: size mode for the layout

        Raises:
            InvalidParamError: size mode does not exist
        """
        if mode not in SIZE_CONSTRAINT:
            raise InvalidParamError(mode, SIZE_CONSTRAINT)
        self.setSizeConstraint(SIZE_CONSTRAINT[mode])

    @deprecated(reason="Use set_size_constraint instead")
    def get_size_mode(self) -> SizeConstraintStr:
        return self.get_size_constraint()

    def get_size_constraint(self) -> SizeConstraintStr:
        """Return current size mode.

        Returns:
            size mode
        """
        return SIZE_CONSTRAINT.inverse[self.sizeConstraint()]

    def set_alignment(
        self,
        alignment: constants.AlignmentStr,
        item: QtWidgets.QWidget | QtWidgets.QLayout | None = None,
    ) -> bool:
        """Set the alignment for widget / layout to alignment.

        Returns true if w is found in this layout (not including child layouts).

        Args:
            alignment: alignment for the layout
            item: set alignment for specific child only

        Raises:
            InvalidParamError: alignment does not exist
        """
        if alignment not in constants.ALIGNMENTS:
            raise InvalidParamError(alignment, constants.ALIGNMENTS)
        if item is not None:
            return self.setAlignment(item, constants.ALIGNMENTS[alignment])
        else:
            return self.setAlignment(constants.ALIGNMENTS[alignment])

    def add_widget(self, widget: QtWidgets.QWidget):
        self.addWidget(widget)

    def add(self, *items: QtWidgets.QWidget | QtWidgets.QLayout):
        for i in items:
            match i:
                case QtWidgets.QWidget():
                    self.addWidget(i)
                case QtWidgets.QLayout():
                    w = widgets.Widget()
                    w.set_layout(i)
                    self.addWidget(w)
                case _:
                    raise TypeError("add_item only supports widgets and layouts")

__contains__(item: QtWidgets.QWidget | QtWidgets.QLayoutItem)

Source code in prettyqt\widgets\layout.py
def __contains__(self, item: QtWidgets.QWidget | QtWidgets.QLayoutItem):
    return self.indexOf(item) >= 0

__delitem__(index: int)

Source code in prettyqt\widgets\layout.py
def __delitem__(self, index: int):
    item = self.itemAt(index)
    self.removeItem(item)

__getitem__(index: str | int) -> QtWidgets.QWidget | QtWidgets.QLayout | None

Source code in prettyqt\widgets\layout.py
def __getitem__(
    self, index: str | int
) -> QtWidgets.QWidget | QtWidgets.QLayout | None:
    if isinstance(index, int):
        item = self.itemAt(index)
        widget = item.widget()
        if widget is None:
            widget = item.layout()
    elif isinstance(index, str):
        return self.find_child(typ=QtCore.QObject, name=index)
    return widget

__iter__() -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout | None]

Source code in prettyqt\widgets\layout.py
def __iter__(self) -> Iterator[QtWidgets.QWidget | QtWidgets.QLayout | None]:
    return iter(self[i] for i in range(self.count()))

__len__() -> int

Source code in prettyqt\widgets\layout.py
def __len__(self) -> int:
    return self.count()

__repr__()

Source code in prettyqt\widgets\layout.py
def __repr__(self):
    return get_repr(self)

add(*items: QtWidgets.QWidget | QtWidgets.QLayout)

Source code in prettyqt\widgets\layout.py
def add(self, *items: QtWidgets.QWidget | QtWidgets.QLayout):
    for i in items:
        match i:
            case QtWidgets.QWidget():
                self.addWidget(i)
            case QtWidgets.QLayout():
                w = widgets.Widget()
                w.set_layout(i)
                self.addWidget(w)
            case _:
                raise TypeError("add_item only supports widgets and layouts")

add_widget(widget: QtWidgets.QWidget)

Source code in prettyqt\widgets\layout.py
def add_widget(self, widget: QtWidgets.QWidget):
    self.addWidget(widget)

get_children() -> list[QtWidgets.QWidget | QtWidgets.QLayout]

Source code in prettyqt\widgets\layout.py
def get_children(self) -> list[QtWidgets.QWidget | QtWidgets.QLayout]:
    return list(self)

get_size_constraint() -> SizeConstraintStr

Return current size mode.

Returns:

Type Description
SizeConstraintStr

size mode

Source code in prettyqt\widgets\layout.py
def get_size_constraint(self) -> SizeConstraintStr:
    """Return current size mode.

    Returns:
        size mode
    """
    return SIZE_CONSTRAINT.inverse[self.sizeConstraint()]

get_size_mode() -> SizeConstraintStr

Source code in prettyqt\widgets\layout.py
@deprecated(reason="Use set_size_constraint instead")
def get_size_mode(self) -> SizeConstraintStr:
    return self.get_size_constraint()

serialize_fields()

Source code in prettyqt\widgets\layout.py
def serialize_fields(self):
    return dict(
        size_mode=self.get_size_mode(),
        spacing=self.spacing(),
        enabled=self.isEnabled(),
    )

set_alignment(alignment: constants.AlignmentStr, item: QtWidgets.QWidget | QtWidgets.QLayout | None = None) -> bool

Set the alignment for widget / layout to alignment.

Returns true if w is found in this layout (not including child layouts).

Parameters:

Name Type Description Default
alignment constants.AlignmentStr

alignment for the layout

required
item QtWidgets.QWidget | QtWidgets.QLayout | None

set alignment for specific child only

None

Raises:

Type Description
InvalidParamError

alignment does not exist

Source code in prettyqt\widgets\layout.py
def set_alignment(
    self,
    alignment: constants.AlignmentStr,
    item: QtWidgets.QWidget | QtWidgets.QLayout | None = None,
) -> bool:
    """Set the alignment for widget / layout to alignment.

    Returns true if w is found in this layout (not including child layouts).

    Args:
        alignment: alignment for the layout
        item: set alignment for specific child only

    Raises:
        InvalidParamError: alignment does not exist
    """
    if alignment not in constants.ALIGNMENTS:
        raise InvalidParamError(alignment, constants.ALIGNMENTS)
    if item is not None:
        return self.setAlignment(item, constants.ALIGNMENTS[alignment])
    else:
        return self.setAlignment(constants.ALIGNMENTS[alignment])

set_margin(margin: int)

Source code in prettyqt\widgets\layout.py
def set_margin(self, margin: int):
    self.setContentsMargins(margin, margin, margin, margin)

set_size_constraint(mode: SizeConstraintStr)

Set the size mode of the layout.

Parameters:

Name Type Description Default
mode SizeConstraintStr

size mode for the layout

required

Raises:

Type Description
InvalidParamError

size mode does not exist

Source code in prettyqt\widgets\layout.py
def set_size_constraint(self, mode: SizeConstraintStr):
    """Set the size mode of the layout.

    Args:
        mode: size mode for the layout

    Raises:
        InvalidParamError: size mode does not exist
    """
    if mode not in SIZE_CONSTRAINT:
        raise InvalidParamError(mode, SIZE_CONSTRAINT)
    self.setSizeConstraint(SIZE_CONSTRAINT[mode])

set_size_mode(mode: SizeConstraintStr)

Source code in prettyqt\widgets\layout.py
@deprecated(reason="Use set_size_constraint instead")
def set_size_mode(self, mode: SizeConstraintStr):
    self.set_size_constraint(mode)

set_spacing(pixels: int)

Source code in prettyqt\widgets\layout.py
def set_spacing(self, pixels: int):
    self.setSpacing(pixels)

LineEdit

Bases: widgets.WidgetMixin, QtWidgets.QLineEdit

Source code in prettyqt\widgets\lineedit.py
class LineEdit(widgets.WidgetMixin, QtWidgets.QLineEdit):
    value_changed = core.Signal(str)

    def __init__(
        self,
        default_value: str = "",
        read_only: bool = False,
        parent: QtWidgets.QWidget | None = None,
    ):
        super().__init__(default_value, parent)
        self.textChanged.connect(self._set_validation_color)
        self.textChanged.connect(self.value_changed)
        self.set_read_only(read_only)

    def __repr__(self):
        return get_repr(self, self.text())

    def __add__(self, other: str):
        self.append_text(other)
        return self

    def font(self) -> gui.Font:
        return gui.Font(super().font())

    def append_text(self, text: str):
        self.set_text(self.text() + text)

    def set_text(self, text: str):
        self.setText(text)

    def set_read_only(self, value: bool = True):
        """Set text to read-only.

        Args:
            value: True, for read-only, otherwise False
        """
        self.setReadOnly(value)

    def set_regex_validator(self, regex: str, flags=0) -> gui.RegularExpressionValidator:
        validator = gui.RegularExpressionValidator(self)
        validator.set_regex(regex, flags)
        self.set_validator(validator)
        return validator

    def set_range(self, lower: int | None, upper: int | None):
        val = gui.IntValidator()
        val.set_range(lower, upper)
        self.set_validator(val)

    def set_validator(self, validator: gui.Validator):
        self.setValidator(validator)
        self._set_validation_color()

    def set_input_mask(self, mask: str):
        match mask:
            case "ip_address":
                mask = "000.000.000.000;_"
            case "mac_address":
                mask = "HH:HH:HH:HH:HH:HH;_"
            case "iso_date":
                mask = "0000-00-00"
        self.setInputMask(mask)

    def _set_validation_color(self, state: bool = True):
        color = None if self.is_valid() else "orange"
        self.set_background_color(color)

    def set_echo_mode(self, mode: EchoModeStr):
        """Set echo mode.

        Args:
            mode: echo mode to use

        Raises:
            InvalidParamError: invalid echo mode
        """
        if mode not in ECHO_MODE:
            raise InvalidParamError(mode, ECHO_MODE)
        self.setEchoMode(ECHO_MODE[mode])

    def get_echo_mode(self) -> EchoModeStr:
        """Return echo mode.

        Returns:
            echo mode
        """
        return ECHO_MODE.inverse[self.echoMode()]

    def set_cursor_move_style(self, style: constants.CursorMoveStyleStr):
        """Set cursor move style.

        Args:
            style: cursor move style to use

        Raises:
            InvalidParamError: invalid cursor move style
        """
        if style not in constants.CURSOR_MOVE_STYLE:
            raise InvalidParamError(style, constants.CURSOR_MOVE_STYLE)
        self.setCursorMoveStyle(constants.CURSOR_MOVE_STYLE[style])

    def get_cursor_move_style(self) -> constants.CursorMoveStyleStr:
        """Return cursor move style.

        Returns:
            cursor move style
        """
        return constants.CURSOR_MOVE_STYLE.inverse[self.cursorMoveStyle()]

    def add_action(
        self, action: QtWidgets.QAction, position: ActionPositionStr = "trailing"
    ):
        self.addAction(action, ACTION_POSITION[position])

    def set_value(self, value: str):
        self.setText(value)

    def get_value(self) -> str:
        return self.text()

    def is_valid(self) -> bool:
        return self.hasAcceptableInput()

value_changed = core.Signal(str) class-attribute

__add__(other: str)

Source code in prettyqt\widgets\lineedit.py
def __add__(self, other: str):
    self.append_text(other)
    return self

__init__(default_value: str = '', read_only: bool = False, parent: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\lineedit.py
def __init__(
    self,
    default_value: str = "",
    read_only: bool = False,
    parent: QtWidgets.QWidget | None = None,
):
    super().__init__(default_value, parent)
    self.textChanged.connect(self._set_validation_color)
    self.textChanged.connect(self.value_changed)
    self.set_read_only(read_only)

__repr__()

Source code in prettyqt\widgets\lineedit.py
def __repr__(self):
    return get_repr(self, self.text())

add_action(action: QtWidgets.QAction, position: ActionPositionStr = 'trailing')

Source code in prettyqt\widgets\lineedit.py
def add_action(
    self, action: QtWidgets.QAction, position: ActionPositionStr = "trailing"
):
    self.addAction(action, ACTION_POSITION[position])

append_text(text: str)

Source code in prettyqt\widgets\lineedit.py
def append_text(self, text: str):
    self.set_text(self.text() + text)

font() -> gui.Font

Source code in prettyqt\widgets\lineedit.py
def font(self) -> gui.Font:
    return gui.Font(super().font())

get_cursor_move_style() -> constants.CursorMoveStyleStr

Return cursor move style.

Returns:

Type Description
constants.CursorMoveStyleStr

cursor move style

Source code in prettyqt\widgets\lineedit.py
def get_cursor_move_style(self) -> constants.CursorMoveStyleStr:
    """Return cursor move style.

    Returns:
        cursor move style
    """
    return constants.CURSOR_MOVE_STYLE.inverse[self.cursorMoveStyle()]

get_echo_mode() -> EchoModeStr

Return echo mode.

Returns:

Type Description
EchoModeStr

echo mode

Source code in prettyqt\widgets\lineedit.py
def get_echo_mode(self) -> EchoModeStr:
    """Return echo mode.

    Returns:
        echo mode
    """
    return ECHO_MODE.inverse[self.echoMode()]

get_value() -> str

Source code in prettyqt\widgets\lineedit.py
def get_value(self) -> str:
    return self.text()

is_valid() -> bool

Source code in prettyqt\widgets\lineedit.py
def is_valid(self) -> bool:
    return self.hasAcceptableInput()

set_cursor_move_style(style: constants.CursorMoveStyleStr)

Set cursor move style.

Parameters:

Name Type Description Default
style constants.CursorMoveStyleStr

cursor move style to use

required

Raises:

Type Description
InvalidParamError

invalid cursor move style

Source code in prettyqt\widgets\lineedit.py
def set_cursor_move_style(self, style: constants.CursorMoveStyleStr):
    """Set cursor move style.

    Args:
        style: cursor move style to use

    Raises:
        InvalidParamError: invalid cursor move style
    """
    if style not in constants.CURSOR_MOVE_STYLE:
        raise InvalidParamError(style, constants.CURSOR_MOVE_STYLE)
    self.setCursorMoveStyle(constants.CURSOR_MOVE_STYLE[style])

set_echo_mode(mode: EchoModeStr)

Set echo mode.

Parameters:

Name Type Description Default
mode EchoModeStr

echo mode to use

required

Raises:

Type Description
InvalidParamError

invalid echo mode

Source code in prettyqt\widgets\lineedit.py
def set_echo_mode(self, mode: EchoModeStr):
    """Set echo mode.

    Args:
        mode: echo mode to use

    Raises:
        InvalidParamError: invalid echo mode
    """
    if mode not in ECHO_MODE:
        raise InvalidParamError(mode, ECHO_MODE)
    self.setEchoMode(ECHO_MODE[mode])

set_input_mask(mask: str)

Source code in prettyqt\widgets\lineedit.py
def set_input_mask(self, mask: str):
    match mask:
        case "ip_address":
            mask = "000.000.000.000;_"
        case "mac_address":
            mask = "HH:HH:HH:HH:HH:HH;_"
        case "iso_date":
            mask = "0000-00-00"
    self.setInputMask(mask)

set_range(lower: int | None, upper: int | None)

Source code in prettyqt\widgets\lineedit.py
def set_range(self, lower: int | None, upper: int | None):
    val = gui.IntValidator()
    val.set_range(lower, upper)
    self.set_validator(val)

set_read_only(value: bool = True)

Set text to read-only.

Parameters:

Name Type Description Default
value bool

True, for read-only, otherwise False

True
Source code in prettyqt\widgets\lineedit.py
def set_read_only(self, value: bool = True):
    """Set text to read-only.

    Args:
        value: True, for read-only, otherwise False
    """
    self.setReadOnly(value)

set_regex_validator(regex: str, flags = 0) -> gui.RegularExpressionValidator

Source code in prettyqt\widgets\lineedit.py
def set_regex_validator(self, regex: str, flags=0) -> gui.RegularExpressionValidator:
    validator = gui.RegularExpressionValidator(self)
    validator.set_regex(regex, flags)
    self.set_validator(validator)
    return validator

set_text(text: str)

Source code in prettyqt\widgets\lineedit.py
def set_text(self, text: str):
    self.setText(text)

set_validator(validator: gui.Validator)

Source code in prettyqt\widgets\lineedit.py
def set_validator(self, validator: gui.Validator):
    self.setValidator(validator)
    self._set_validation_color()

set_value(value: str)

Source code in prettyqt\widgets\lineedit.py
def set_value(self, value: str):
    self.setText(value)

ListView

Bases: ListViewMixin, QtWidgets.QListView

Source code in prettyqt\widgets\listview.py
class ListView(ListViewMixin, QtWidgets.QListView):
    pass

ListViewMixin

Bases: widgets.AbstractItemViewMixin

Source code in prettyqt\widgets\listview.py
class ListViewMixin(widgets.AbstractItemViewMixin):
    def set_view_mode(self, mode: ViewModeStr):
        """Set view mode.

        Args:
            mode: view mode to use

        Raises:
            InvalidParamError: invalid view mode
        """
        if mode not in VIEW_MODE:
            raise InvalidParamError(mode, VIEW_MODE)
        self.setViewMode(VIEW_MODE[mode])

    def get_view_mode(self) -> ViewModeStr:
        """Return view mode.

        Returns:
            view mode
        """
        return VIEW_MODE.inverse[self.viewMode()]

    def set_resize_mode(self, mode: ResizeModeStr):
        """Set resize mode.

        Args:
            mode: resize mode to use

        Raises:
            InvalidParamError: invalid resize mode
        """
        if mode not in RESIZE_MODE:
            raise InvalidParamError(mode, RESIZE_MODE)
        self.setResizeMode(RESIZE_MODE[mode])

    def get_resize_mode(self) -> ResizeModeStr:
        """Return resize mode.

        Returns:
            resize mode
        """
        return RESIZE_MODE.inverse[self.resizeMode()]

    def set_layout_mode(self, mode: LayoutModeStr):
        """Set layout mode.

        Args:
            mode: layout mode to use

        Raises:
            InvalidParamError: invalid layout mode
        """
        if mode not in LAYOUT_MODE:
            raise InvalidParamError(mode, LAYOUT_MODE)
        self.setLayoutMode(LAYOUT_MODE[mode])

    def get_layout_mode(self) -> LayoutModeStr:
        """Return layout mode.

        Returns:
            layout mode
        """
        return LAYOUT_MODE.inverse[self.layoutMode()]

    def set_movement(self, mode: MovementStr):
        """Set movement mode.

        Args:
            mode: movement mode to use

        Raises:
            InvalidParamError: invalid movement mode
        """
        if mode not in MOVEMENT:
            raise InvalidParamError(mode, MOVEMENT)
        self.setMovement(MOVEMENT[mode])

    def get_movement(self) -> MovementStr:
        """Return movement mode.

        Returns:
            movement mode
        """
        return MOVEMENT.inverse[self.movement()]

    def set_flow(self, mode: FlowStr):
        """Set flow mode.

        Args:
            mode: flow mode to use

        Raises:
            InvalidParamError: invalid flow mode
        """
        if mode not in FLOW:
            raise InvalidParamError(mode, FLOW)
        self.setFlow(FLOW[mode])

    def get_flow(self) -> FlowStr:
        """Return flow mode.

        Returns:
            flow mode
        """
        return FLOW.inverse[self.flow()]

    def set_grid_size(self, size: QtCore.QSize | tuple[int, int]):
        if isinstance(size, tuple):
            size = QtCore.QSize(*size)
        self.setGridSize(size)

    def get_grid_size(self) -> core.Size:
        return core.Size(self.gridSize())

get_flow() -> FlowStr

Return flow mode.

Returns:

Type Description
FlowStr

flow mode

Source code in prettyqt\widgets\listview.py
def get_flow(self) -> FlowStr:
    """Return flow mode.

    Returns:
        flow mode
    """
    return FLOW.inverse[self.flow()]

get_grid_size() -> core.Size

Source code in prettyqt\widgets\listview.py
def get_grid_size(self) -> core.Size:
    return core.Size(self.gridSize())

get_layout_mode() -> LayoutModeStr

Return layout mode.

Returns:

Type Description
LayoutModeStr

layout mode

Source code in prettyqt\widgets\listview.py
def get_layout_mode(self) -> LayoutModeStr:
    """Return layout mode.

    Returns:
        layout mode
    """
    return LAYOUT_MODE.inverse[self.layoutMode()]

get_movement() -> MovementStr

Return movement mode.

Returns:

Type Description
MovementStr

movement mode

Source code in prettyqt\widgets\listview.py
def get_movement(self) -> MovementStr:
    """Return movement mode.

    Returns:
        movement mode
    """
    return MOVEMENT.inverse[self.movement()]

get_resize_mode() -> ResizeModeStr

Return resize mode.

Returns:

Type Description
ResizeModeStr

resize mode

Source code in prettyqt\widgets\listview.py
def get_resize_mode(self) -> ResizeModeStr:
    """Return resize mode.

    Returns:
        resize mode
    """
    return RESIZE_MODE.inverse[self.resizeMode()]

get_view_mode() -> ViewModeStr

Return view mode.

Returns:

Type Description
ViewModeStr

view mode

Source code in prettyqt\widgets\listview.py
def get_view_mode(self) -> ViewModeStr:
    """Return view mode.

    Returns:
        view mode
    """
    return VIEW_MODE.inverse[self.viewMode()]

set_flow(mode: FlowStr)

Set flow mode.

Parameters:

Name Type Description Default
mode FlowStr

flow mode to use

required

Raises:

Type Description
InvalidParamError

invalid flow mode

Source code in prettyqt\widgets\listview.py
def set_flow(self, mode: FlowStr):
    """Set flow mode.

    Args:
        mode: flow mode to use

    Raises:
        InvalidParamError: invalid flow mode
    """
    if mode not in FLOW:
        raise InvalidParamError(mode, FLOW)
    self.setFlow(FLOW[mode])

set_grid_size(size: QtCore.QSize | tuple[int, int])

Source code in prettyqt\widgets\listview.py
def set_grid_size(self, size: QtCore.QSize | tuple[int, int]):
    if isinstance(size, tuple):
        size = QtCore.QSize(*size)
    self.setGridSize(size)

set_layout_mode(mode: LayoutModeStr)

Set layout mode.

Parameters:

Name Type Description Default
mode LayoutModeStr

layout mode to use

required

Raises:

Type Description
InvalidParamError

invalid layout mode

Source code in prettyqt\widgets\listview.py
def set_layout_mode(self, mode: LayoutModeStr):
    """Set layout mode.

    Args:
        mode: layout mode to use

    Raises:
        InvalidParamError: invalid layout mode
    """
    if mode not in LAYOUT_MODE:
        raise InvalidParamError(mode, LAYOUT_MODE)
    self.setLayoutMode(LAYOUT_MODE[mode])

set_movement(mode: MovementStr)

Set movement mode.

Parameters:

Name Type Description Default
mode MovementStr

movement mode to use

required

Raises:

Type Description
InvalidParamError

invalid movement mode

Source code in prettyqt\widgets\listview.py
def set_movement(self, mode: MovementStr):
    """Set movement mode.

    Args:
        mode: movement mode to use

    Raises:
        InvalidParamError: invalid movement mode
    """
    if mode not in MOVEMENT:
        raise InvalidParamError(mode, MOVEMENT)
    self.setMovement(MOVEMENT[mode])

set_resize_mode(mode: ResizeModeStr)

Set resize mode.

Parameters:

Name Type Description Default
mode ResizeModeStr

resize mode to use

required

Raises:

Type Description
InvalidParamError

invalid resize mode

Source code in prettyqt\widgets\listview.py
def set_resize_mode(self, mode: ResizeModeStr):
    """Set resize mode.

    Args:
        mode: resize mode to use

    Raises:
        InvalidParamError: invalid resize mode
    """
    if mode not in RESIZE_MODE:
        raise InvalidParamError(mode, RESIZE_MODE)
    self.setResizeMode(RESIZE_MODE[mode])

set_view_mode(mode: ViewModeStr)

Set view mode.

Parameters:

Name Type Description Default
mode ViewModeStr

view mode to use

required

Raises:

Type Description
InvalidParamError

invalid view mode

Source code in prettyqt\widgets\listview.py
def set_view_mode(self, mode: ViewModeStr):
    """Set view mode.

    Args:
        mode: view mode to use

    Raises:
        InvalidParamError: invalid view mode
    """
    if mode not in VIEW_MODE:
        raise InvalidParamError(mode, VIEW_MODE)
    self.setViewMode(VIEW_MODE[mode])

ListWidget

Bases: widgets.ListViewMixin, QtWidgets.QListWidget

Source code in prettyqt\widgets\listwidget.py
class ListWidget(widgets.ListViewMixin, QtWidgets.QListWidget):
    value_changed = core.Signal(object)

    def __init__(
        self, parent: QtWidgets.QWidget | None = None, selection_mode: str = "single"
    ):
        super().__init__(parent)
        self.itemSelectionChanged.connect(self.on_index_change)
        self.set_selection_mode(selection_mode)

    def __repr__(self):
        return f"{type(self).__name__}: {self.count()} items"

    def __getitem__(self, row: int) -> QtWidgets.QListWidgetItem:
        item = self.item(row)
        if item is None:
            raise KeyError(row)
        return item

    def __delitem__(self, row: int):
        self.takeItem(row)

    def __add__(self, other: QtWidgets.QListWidgetItem):
        self.addItem(other)
        return self

    def __iter__(self) -> Iterator[QtWidgets.QListWidgetItem]:
        return iter(self.get_children())

    def __len__(self) -> int:
        return self.count()

    # def __setstate__(self, state):
    #     self.set_selection_mode(state["selection_mode"])
    #     self.setSortingEnabled(state["sorting_enabled"])
    #     self.setCurrentRow(state["current_row"])
    #     for item in state["items"]:
    #         self.addItem(item)

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    # def serialize_fields(self):
    #     return dict(
    #         items=self.get_children(),
    #         selection_mode=self.get_selection_mode(),
    #         sorting_enabled=self.isSortingEnabled(),
    #         current_row=self.currentRow(),
    #     )

    def sort(self, reverse: bool = False):
        order = constants.DESCENDING if reverse else constants.ASCENDING
        self.sortItems(order)

    def on_index_change(self):
        data = self.get_value()
        self.value_changed.emit(data)

    def get_children(self) -> list[QtWidgets.QListWidgetItem]:
        return [self.item(row) for row in range(self.count())]

    def add_items(self, items: Iterable | Mapping):
        if isinstance(items, Mapping):
            for k, v in items.items():
                self.add(v, k)
        else:
            for i in items:
                if isinstance(i, tuple | list):
                    self.add(*i)
                else:
                    self.add(i)

    def add_item(
        self,
        name: str = "",
        icon: datatypes.IconType = None,
        data: dict | None = None,
        foreground: QtGui.QBrush | None = None,
        background: QtGui.QBrush | None = None,
        font: QtGui.QFont | None = None,
        selected: bool = None,
        status_tip: str | None = None,
        tool_tip: str | None = None,
        whats_this: str | None = None,
        # text_alignment: Optional[str] = None,
        checkstate: constants.StateStr | None = None,
        flags: QtCore.Qt.ItemFlag | None = None,
        size_hint: datatypes.SizeType | None = None,
        is_user_type: bool = False,
    ) -> widgets.ListWidgetItem:
        typ = 1 if is_user_type else 0
        item = widgets.ListWidgetItem(name, self, typ)
        if icon is not None:
            icon = iconprovider.get_icon(icon)
            item.setIcon(icon)
        if data is not None:
            for k, v in data.items():
                item.setData(k, v)
        if foreground is not None:
            item.setForeground(foreground)
        if background is not None:
            item.setBackground(background)
        if font is not None:
            item.setFont(font)
        if flags is not None:
            item.setFlags(flags)
        if selected:
            item.setSelected(selected)
        if status_tip:
            item.setStatusTip(status_tip)
        if tool_tip:
            item.setToolTip(tool_tip)
        if whats_this:
            item.setWhatsThis(whats_this)
        if size_hint is not None:
            item.set_size_hint(size_hint)
        if checkstate is not None:
            item.set_checkstate(checkstate)
        self.addItem(item)
        return item

    def add(self, label: str, data=NoData, icon: datatypes.IconType = None):
        if data is NoData:
            data = label
        item = widgets.ListWidgetItem(label)
        item.set_icon(icon)
        item.setData(constants.USER_ROLE, data)  # type: ignore
        self.addItem(item)

    def get_value(self) -> list[Any]:
        return [i.data(constants.USER_ROLE) for i in self.selectedItems()]  # type: ignore

    def set_value(self, value):
        for i in self.get_children():
            if i.data(constants.USER_ROLE) in value:  # type: ignore
                self.setCurrentItem(i)
                break

    def scroll_to_item(
        self,
        item: QtWidgets.QListWidgetItem,
        mode: widgets.abstractitemview.ScrollHintStr = "ensure_visible",
    ):
        if mode not in widgets.abstractitemview.SCROLL_HINT:
            raise InvalidParamError(mode, widgets.abstractitemview.SCROLL_HINT)
        self.scrollToItem(item, widgets.abstractitemview.SCROLL_HINT[mode])

    def find_items(
        self, text: str, column: int = 0, mode: constants.MatchFlagStr = "exact"
    ) -> list[QtGui.QStandardItem]:
        if mode not in constants.MATCH_FLAGS:
            raise InvalidParamError(mode, constants.MATCH_FLAGS)
        return self.findItems(text, constants.MATCH_FLAGS[mode], column)  # type: ignore

value_changed = core.Signal(object) class-attribute

__add__(other: QtWidgets.QListWidgetItem)

Source code in prettyqt\widgets\listwidget.py
def __add__(self, other: QtWidgets.QListWidgetItem):
    self.addItem(other)
    return self

__delitem__(row: int)

Source code in prettyqt\widgets\listwidget.py
def __delitem__(self, row: int):
    self.takeItem(row)

__getitem__(row: int) -> QtWidgets.QListWidgetItem

Source code in prettyqt\widgets\listwidget.py
def __getitem__(self, row: int) -> QtWidgets.QListWidgetItem:
    item = self.item(row)
    if item is None:
        raise KeyError(row)
    return item

__init__(parent: QtWidgets.QWidget | None = None, selection_mode: str = 'single')

Source code in prettyqt\widgets\listwidget.py
def __init__(
    self, parent: QtWidgets.QWidget | None = None, selection_mode: str = "single"
):
    super().__init__(parent)
    self.itemSelectionChanged.connect(self.on_index_change)
    self.set_selection_mode(selection_mode)

__iter__() -> Iterator[QtWidgets.QListWidgetItem]

Source code in prettyqt\widgets\listwidget.py
def __iter__(self) -> Iterator[QtWidgets.QListWidgetItem]:
    return iter(self.get_children())

__len__() -> int

Source code in prettyqt\widgets\listwidget.py
def __len__(self) -> int:
    return self.count()

__repr__()

Source code in prettyqt\widgets\listwidget.py
def __repr__(self):
    return f"{type(self).__name__}: {self.count()} items"

add(label: str, data = NoData, icon: datatypes.IconType = None)

Source code in prettyqt\widgets\listwidget.py
def add(self, label: str, data=NoData, icon: datatypes.IconType = None):
    if data is NoData:
        data = label
    item = widgets.ListWidgetItem(label)
    item.set_icon(icon)
    item.setData(constants.USER_ROLE, data)  # type: ignore
    self.addItem(item)

add_item(name: str = '', icon: datatypes.IconType = None, data: dict | None = None, foreground: QtGui.QBrush | None = None, background: QtGui.QBrush | None = None, font: QtGui.QFont | None = None, selected: bool = None, status_tip: str | None = None, tool_tip: str | None = None, whats_this: str | None = None, checkstate: constants.StateStr | None = None, flags: QtCore.Qt.ItemFlag | None = None, size_hint: datatypes.SizeType | None = None, is_user_type: bool = False) -> widgets.ListWidgetItem

Source code in prettyqt\widgets\listwidget.py
def add_item(
    self,
    name: str = "",
    icon: datatypes.IconType = None,
    data: dict | None = None,
    foreground: QtGui.QBrush | None = None,
    background: QtGui.QBrush | None = None,
    font: QtGui.QFont | None = None,
    selected: bool = None,
    status_tip: str | None = None,
    tool_tip: str | None = None,
    whats_this: str | None = None,
    # text_alignment: Optional[str] = None,
    checkstate: constants.StateStr | None = None,
    flags: QtCore.Qt.ItemFlag | None = None,
    size_hint: datatypes.SizeType | None = None,
    is_user_type: bool = False,
) -> widgets.ListWidgetItem:
    typ = 1 if is_user_type else 0
    item = widgets.ListWidgetItem(name, self, typ)
    if icon is not None:
        icon = iconprovider.get_icon(icon)
        item.setIcon(icon)
    if data is not None:
        for k, v in data.items():
            item.setData(k, v)
    if foreground is not None:
        item.setForeground(foreground)
    if background is not None:
        item.setBackground(background)
    if font is not None:
        item.setFont(font)
    if flags is not None:
        item.setFlags(flags)
    if selected:
        item.setSelected(selected)
    if status_tip:
        item.setStatusTip(status_tip)
    if tool_tip:
        item.setToolTip(tool_tip)
    if whats_this:
        item.setWhatsThis(whats_this)
    if size_hint is not None:
        item.set_size_hint(size_hint)
    if checkstate is not None:
        item.set_checkstate(checkstate)
    self.addItem(item)
    return item

add_items(items: Iterable | Mapping)

Source code in prettyqt\widgets\listwidget.py
def add_items(self, items: Iterable | Mapping):
    if isinstance(items, Mapping):
        for k, v in items.items():
            self.add(v, k)
    else:
        for i in items:
            if isinstance(i, tuple | list):
                self.add(*i)
            else:
                self.add(i)

find_items(text: str, column: int = 0, mode: constants.MatchFlagStr = 'exact') -> list[QtGui.QStandardItem]

Source code in prettyqt\widgets\listwidget.py
def find_items(
    self, text: str, column: int = 0, mode: constants.MatchFlagStr = "exact"
) -> list[QtGui.QStandardItem]:
    if mode not in constants.MATCH_FLAGS:
        raise InvalidParamError(mode, constants.MATCH_FLAGS)
    return self.findItems(text, constants.MATCH_FLAGS[mode], column)  # type: ignore

get_children() -> list[QtWidgets.QListWidgetItem]

Source code in prettyqt\widgets\listwidget.py
def get_children(self) -> list[QtWidgets.QListWidgetItem]:
    return [self.item(row) for row in range(self.count())]

get_value() -> list[Any]

Source code in prettyqt\widgets\listwidget.py
def get_value(self) -> list[Any]:
    return [i.data(constants.USER_ROLE) for i in self.selectedItems()]  # type: ignore

on_index_change()

Source code in prettyqt\widgets\listwidget.py
def on_index_change(self):
    data = self.get_value()
    self.value_changed.emit(data)

scroll_to_item(item: QtWidgets.QListWidgetItem, mode: widgets.abstractitemview.ScrollHintStr = 'ensure_visible')

Source code in prettyqt\widgets\listwidget.py
def scroll_to_item(
    self,
    item: QtWidgets.QListWidgetItem,
    mode: widgets.abstractitemview.ScrollHintStr = "ensure_visible",
):
    if mode not in widgets.abstractitemview.SCROLL_HINT:
        raise InvalidParamError(mode, widgets.abstractitemview.SCROLL_HINT)
    self.scrollToItem(item, widgets.abstractitemview.SCROLL_HINT[mode])

set_value(value)

Source code in prettyqt\widgets\listwidget.py
def set_value(self, value):
    for i in self.get_children():
        if i.data(constants.USER_ROLE) in value:  # type: ignore
            self.setCurrentItem(i)
            break

sort(reverse: bool = False)

Source code in prettyqt\widgets\listwidget.py
def sort(self, reverse: bool = False):
    order = constants.DESCENDING if reverse else constants.ASCENDING
    self.sortItems(order)

ListWidgetItem

Bases: serializemixin.SerializeMixin, QtWidgets.QListWidgetItem

Source code in prettyqt\widgets\listwidgetitem.py
class ListWidgetItem(serializemixin.SerializeMixin, QtWidgets.QListWidgetItem):
    def __repr__(self):
        return get_repr(self, self.icon(), self.text())

    def __setitem__(self, index: int, value):
        self.setData(index, value)

    def __getitem__(self, index: int):
        return self.data(index)

    def serialize_fields(self):
        return dict(
            text=self.text(),
            tool_tip=self.toolTip(),
            status_tip=self.statusTip(),
            checkstate=self.get_checkstate(),
            icon=self.get_icon(),
            data=self.data(constants.USER_ROLE),  # type: ignore
        )

    def set_icon(self, icon: datatypes.IconType):
        """Set the icon for the action.

        Args:
            icon: icon to use
        """
        icon = iconprovider.get_icon(icon)
        self.setIcon(icon)

    def set_checkstate(self, state: constants.StateStr):
        """Set checkstate of the checkbox.

        Args:
            state: checkstate to use

        Raises:
            InvalidParamError: invalid checkstate
        """
        if state not in constants.STATE:
            raise InvalidParamError(state, constants.STATE)
        self.setCheckState(constants.STATE[state])

    def get_checkstate(self) -> constants.StateStr:
        """Return checkstate.

        Returns:
            checkstate
        """
        return constants.STATE.inverse[self.checkState()]

    def get_background(self) -> gui.Brush:
        return gui.Brush(self.background())

    def get_foreground(self) -> gui.Brush:
        return gui.Brush(self.foreground())

    def get_font(self) -> gui.Font:
        return gui.Font(self.font())

    def get_icon(self) -> gui.Icon | None:
        icon = self.icon()
        return None if icon.isNull() else gui.Icon(icon)

    def set_data(self, role: str, data):
        role_id = constants.ITEM_DATA_ROLE[role]
        self.setData(role_id, data)

    def set_size_hint(self, hint: datatypes.SizeType):
        if isinstance(hint, tuple):
            hint = QtCore.QSize(*hint)
        self.setSizeHint(hint)

    def set_text_alignment(
        self,
        horizontal: constants.HorizontalAlignmentStr | None = None,
        vertical: constants.VerticalAlignmentStr | None = None,
    ):
        """Set text alignment of the checkbox.

        Args:
            horizontal: horizontal text alignment to use
            vertical: vertical text alignment to use

        Raises:
            InvalidParamError: invalid text alignment
        """
        match horizontal, vertical:
            case None, None:
                return
            case None, _:
                flag = constants.V_ALIGNMENT[vertical]
            case _, None:
                flag = constants.H_ALIGNMENT[horizontal]
            case _, _:
                flag = constants.V_ALIGNMENT[vertical] | constants.H_ALIGNMENT[horizontal]
        self.setTextAlignment(flag)

__getitem__(index: int)

Source code in prettyqt\widgets\listwidgetitem.py
def __getitem__(self, index: int):
    return self.data(index)

__repr__()

Source code in prettyqt\widgets\listwidgetitem.py
def __repr__(self):
    return get_repr(self, self.icon(), self.text())

__setitem__(index: int, value)

Source code in prettyqt\widgets\listwidgetitem.py
def __setitem__(self, index: int, value):
    self.setData(index, value)

get_background() -> gui.Brush

Source code in prettyqt\widgets\listwidgetitem.py
def get_background(self) -> gui.Brush:
    return gui.Brush(self.background())

get_checkstate() -> constants.StateStr

Return checkstate.

Returns:

Type Description
constants.StateStr

checkstate

Source code in prettyqt\widgets\listwidgetitem.py
def get_checkstate(self) -> constants.StateStr:
    """Return checkstate.

    Returns:
        checkstate
    """
    return constants.STATE.inverse[self.checkState()]

get_font() -> gui.Font

Source code in prettyqt\widgets\listwidgetitem.py
def get_font(self) -> gui.Font:
    return gui.Font(self.font())

get_foreground() -> gui.Brush

Source code in prettyqt\widgets\listwidgetitem.py
def get_foreground(self) -> gui.Brush:
    return gui.Brush(self.foreground())

get_icon() -> gui.Icon | None

Source code in prettyqt\widgets\listwidgetitem.py
def get_icon(self) -> gui.Icon | None:
    icon = self.icon()
    return None if icon.isNull() else gui.Icon(icon)

serialize_fields()

Source code in prettyqt\widgets\listwidgetitem.py
def serialize_fields(self):
    return dict(
        text=self.text(),
        tool_tip=self.toolTip(),
        status_tip=self.statusTip(),
        checkstate=self.get_checkstate(),
        icon=self.get_icon(),
        data=self.data(constants.USER_ROLE),  # type: ignore
    )

set_checkstate(state: constants.StateStr)

Set checkstate of the checkbox.

Parameters:

Name Type Description Default
state constants.StateStr

checkstate to use

required

Raises:

Type Description
InvalidParamError

invalid checkstate

Source code in prettyqt\widgets\listwidgetitem.py
def set_checkstate(self, state: constants.StateStr):
    """Set checkstate of the checkbox.

    Args:
        state: checkstate to use

    Raises:
        InvalidParamError: invalid checkstate
    """
    if state not in constants.STATE:
        raise InvalidParamError(state, constants.STATE)
    self.setCheckState(constants.STATE[state])

set_data(role: str, data)

Source code in prettyqt\widgets\listwidgetitem.py
def set_data(self, role: str, data):
    role_id = constants.ITEM_DATA_ROLE[role]
    self.setData(role_id, data)

set_icon(icon: datatypes.IconType)

Set the icon for the action.

Parameters:

Name Type Description Default
icon datatypes.IconType

icon to use

required
Source code in prettyqt\widgets\listwidgetitem.py
def set_icon(self, icon: datatypes.IconType):
    """Set the icon for the action.

    Args:
        icon: icon to use
    """
    icon = iconprovider.get_icon(icon)
    self.setIcon(icon)

set_size_hint(hint: datatypes.SizeType)

Source code in prettyqt\widgets\listwidgetitem.py
def set_size_hint(self, hint: datatypes.SizeType):
    if isinstance(hint, tuple):
        hint = QtCore.QSize(*hint)
    self.setSizeHint(hint)

set_text_alignment(horizontal: constants.HorizontalAlignmentStr | None = None, vertical: constants.VerticalAlignmentStr | None = None)

Set text alignment of the checkbox.

Parameters:

Name Type Description Default
horizontal constants.HorizontalAlignmentStr | None

horizontal text alignment to use

None
vertical constants.VerticalAlignmentStr | None

vertical text alignment to use

None

Raises:

Type Description
InvalidParamError

invalid text alignment

Source code in prettyqt\widgets\listwidgetitem.py
def set_text_alignment(
    self,
    horizontal: constants.HorizontalAlignmentStr | None = None,
    vertical: constants.VerticalAlignmentStr | None = None,
):
    """Set text alignment of the checkbox.

    Args:
        horizontal: horizontal text alignment to use
        vertical: vertical text alignment to use

    Raises:
        InvalidParamError: invalid text alignment
    """
    match horizontal, vertical:
        case None, None:
            return
        case None, _:
            flag = constants.V_ALIGNMENT[vertical]
        case _, None:
            flag = constants.H_ALIGNMENT[horizontal]
        case _, _:
            flag = constants.V_ALIGNMENT[vertical] | constants.H_ALIGNMENT[horizontal]
    self.setTextAlignment(flag)

MainWindow

Bases: widgets.WidgetMixin, QtWidgets.QMainWindow

Class for our mainWindow.

Includes all docks, a centralwidget and a toolbar

Source code in prettyqt\widgets\mainwindow.py
class MainWindow(widgets.WidgetMixin, QtWidgets.QMainWindow):
    """Class for our mainWindow.

    Includes all docks, a centralwidget and a toolbar
    """

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.setMenuBar(widgets.MenuBar())
        self.setDockOptions(
            self.DockOption.AllowTabbedDocks  # type: ignore
            | self.DockOption.AllowNestedDocks
            | self.DockOption.GroupedDragging
            | self.DockOption.AnimatedDocks
        )

    def __getitem__(self, index: str) -> QtWidgets.QWidget:
        result = self.find_child(QtWidgets.QWidget, index)
        if result is None:
            raise KeyError("Widget not found")
        return result

    def set_widget(self, widget: QtWidgets.QWidget | None):
        if widget is None:
            self.takeCentralWidget()
        else:
            self.setCentralWidget(widget)

    def createPopupMenu(self) -> widgets.Menu:
        # qactions = self.createPopupMenu()
        menu = widgets.Menu(parent=self)
        for i, item in enumerate(self.get_docks()):
            action = widgets.Action(text=item.windowTitle(), parent=self)
            action.set_checkable(True)
            action.set_checked(item.isVisible())
            action.set_shortcut(f"Ctrl+Shift+{i}")
            action.set_shortcut_context("application")
            action.toggled.connect(item.setVisible)
            menu.add(action)
        menu.add_separator()
        for tb in self.get_toolbars():
            action = widgets.Action(text=tb.windowTitle(), parent=self)
            action.set_checkable(True)
            action.toggled.connect(tb.setVisible)
            action.set_checked(tb.isVisible())
            menu.add(action)
        return menu

    def add_toolbar(
        self, toolbar: QtWidgets.QToolBar, position: constants.ToolbarAreaStr = "top"
    ):
        """Adds a toolbar to the mainmenu at specified area.

        Args:
            toolbar: toolbar to use
            position: position of the toolbar

        Raises:
            InvalidParamError: position does not exist
        """
        if position not in constants.TOOLBAR_AREA:
            raise InvalidParamError(position, constants.TOOLBAR_AREA)
        self.addToolBar(constants.TOOLBAR_AREA[position], toolbar)

    def add_toolbar_break(self, position: constants.ToolbarAreaStr = "top"):
        """Adds a toolbar break to the given area behind the last item.

        Args:
            position: position of the toolbar

        Raises:
            InvalidParamError: position does not exist
        """
        if position not in constants.TOOLBAR_AREA:
            raise InvalidParamError(position, constants.TOOLBAR_AREA)
        self.addToolBarBreak(constants.TOOLBAR_AREA[position])

    def load_window_state(self, recursive: bool = False) -> bool:
        settings = core.Settings()
        name = self.get_id()
        geom = settings.get(f"{name}.geometry")
        state = settings.get(f"{name}.state")
        restored = False
        if geom is not None and state is not None:
            try:
                logger.debug(f"Loading window state for {self.windowTitle()!r}...")
                self.restoreGeometry(geom)
                if isinstance(state, str):
                    state = state.encode()
                self.restoreState(state)
                restored = True
            except TypeError:
                logger.error("Wrong type for window state. Probably Qt binding switch?")
        if recursive:
            for window in self.find_children(MainWindow, recursive=True):
                if window.get_id():
                    window.load_window_state()
        return restored

    def save_window_state(self, recursive: bool = False):
        """Save current window state as QSetting.

        Args:
            recursive (bool, optional): Description
        """
        settings = core.Settings()
        name = self.get_id()
        logger.debug(f"Saving window state for {self.windowTitle()!r}...")
        settings[f"{name}.geometry"] = self.saveGeometry()
        settings[f"{name}.state"] = self.saveState()
        if recursive:
            for window in self.find_children(MainWindow, recursive=True):
                if window.get_id():
                    window.save_window_state()

    def add_widget_as_dock(
        self,
        name: str,
        title: str,
        vertical: bool = True,
        position: constants.DockPositionStr = "left",
    ) -> widgets.DockWidget:
        dock_widget = widgets.DockWidget(self, name=name, title=title)
        widget = widgets.Widget()
        widget.set_id(f"{name}.widget")
        layout = widgets.BoxLayout(
            "vertical" if vertical else "horizontal", widget, margin=0
        )
        dock_widget.setWidget(widget)
        self.add_dockwidget(dock_widget, position)
        dock_widget.box = layout
        return dock_widget

    def add_dockwidget(
        self,
        dockwidget: QtWidgets.QDockWidget,
        position: constants.DockPositionStr = "left",
    ):
        self.addDockWidget(constants.DOCK_POSITION[position], dockwidget)

    def remove_dockwidgets(self, dockwidgets: Sequence[QtWidgets.QDockWidget]):
        for i in dockwidgets:
            self.removeDockWidget(i)

    def show_blocking(self):
        self.set_modality("application")
        self.show()

    def get_docks(self) -> list[QtWidgets.QDockWidget]:
        return self.find_children(QtWidgets.QDockWidget, recursive=False)

    def get_toolbars(self) -> list[QtWidgets.QToolBar]:
        return self.find_children(QtWidgets.QToolBar, recursive=False)

__getitem__(index: str) -> QtWidgets.QWidget

Source code in prettyqt\widgets\mainwindow.py
def __getitem__(self, index: str) -> QtWidgets.QWidget:
    result = self.find_child(QtWidgets.QWidget, index)
    if result is None:
        raise KeyError("Widget not found")
    return result

__init__(*args, **kwargs)

Source code in prettyqt\widgets\mainwindow.py
def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.setMenuBar(widgets.MenuBar())
    self.setDockOptions(
        self.DockOption.AllowTabbedDocks  # type: ignore
        | self.DockOption.AllowNestedDocks
        | self.DockOption.GroupedDragging
        | self.DockOption.AnimatedDocks
    )

add_dockwidget(dockwidget: QtWidgets.QDockWidget, position: constants.DockPositionStr = 'left')

Source code in prettyqt\widgets\mainwindow.py
def add_dockwidget(
    self,
    dockwidget: QtWidgets.QDockWidget,
    position: constants.DockPositionStr = "left",
):
    self.addDockWidget(constants.DOCK_POSITION[position], dockwidget)

add_toolbar(toolbar: QtWidgets.QToolBar, position: constants.ToolbarAreaStr = 'top')

Adds a toolbar to the mainmenu at specified area.

Parameters:

Name Type Description Default
toolbar QtWidgets.QToolBar

toolbar to use

required
position constants.ToolbarAreaStr

position of the toolbar

'top'

Raises:

Type Description
InvalidParamError

position does not exist

Source code in prettyqt\widgets\mainwindow.py
def add_toolbar(
    self, toolbar: QtWidgets.QToolBar, position: constants.ToolbarAreaStr = "top"
):
    """Adds a toolbar to the mainmenu at specified area.

    Args:
        toolbar: toolbar to use
        position: position of the toolbar

    Raises:
        InvalidParamError: position does not exist
    """
    if position not in constants.TOOLBAR_AREA:
        raise InvalidParamError(position, constants.TOOLBAR_AREA)
    self.addToolBar(constants.TOOLBAR_AREA[position], toolbar)

add_toolbar_break(position: constants.ToolbarAreaStr = 'top')

Adds a toolbar break to the given area behind the last item.

Parameters:

Name Type Description Default
position constants.ToolbarAreaStr

position of the toolbar

'top'

Raises:

Type Description
InvalidParamError

position does not exist

Source code in prettyqt\widgets\mainwindow.py
def add_toolbar_break(self, position: constants.ToolbarAreaStr = "top"):
    """Adds a toolbar break to the given area behind the last item.

    Args:
        position: position of the toolbar

    Raises:
        InvalidParamError: position does not exist
    """
    if position not in constants.TOOLBAR_AREA:
        raise InvalidParamError(position, constants.TOOLBAR_AREA)
    self.addToolBarBreak(constants.TOOLBAR_AREA[position])

add_widget_as_dock(name: str, title: str, vertical: bool = True, position: constants.DockPositionStr = 'left') -> widgets.DockWidget

Source code in prettyqt\widgets\mainwindow.py
def add_widget_as_dock(
    self,
    name: str,
    title: str,
    vertical: bool = True,
    position: constants.DockPositionStr = "left",
) -> widgets.DockWidget:
    dock_widget = widgets.DockWidget(self, name=name, title=title)
    widget = widgets.Widget()
    widget.set_id(f"{name}.widget")
    layout = widgets.BoxLayout(
        "vertical" if vertical else "horizontal", widget, margin=0
    )
    dock_widget.setWidget(widget)
    self.add_dockwidget(dock_widget, position)
    dock_widget.box = layout
    return dock_widget

createPopupMenu() -> widgets.Menu

Source code in prettyqt\widgets\mainwindow.py
def createPopupMenu(self) -> widgets.Menu:
    # qactions = self.createPopupMenu()
    menu = widgets.Menu(parent=self)
    for i, item in enumerate(self.get_docks()):
        action = widgets.Action(text=item.windowTitle(), parent=self)
        action.set_checkable(True)
        action.set_checked(item.isVisible())
        action.set_shortcut(f"Ctrl+Shift+{i}")
        action.set_shortcut_context("application")
        action.toggled.connect(item.setVisible)
        menu.add(action)
    menu.add_separator()
    for tb in self.get_toolbars():
        action = widgets.Action(text=tb.windowTitle(), parent=self)
        action.set_checkable(True)
        action.toggled.connect(tb.setVisible)
        action.set_checked(tb.isVisible())
        menu.add(action)
    return menu

get_docks() -> list[QtWidgets.QDockWidget]

Source code in prettyqt\widgets\mainwindow.py
def get_docks(self) -> list[QtWidgets.QDockWidget]:
    return self.find_children(QtWidgets.QDockWidget, recursive=False)

get_toolbars() -> list[QtWidgets.QToolBar]

Source code in prettyqt\widgets\mainwindow.py
def get_toolbars(self) -> list[QtWidgets.QToolBar]:
    return self.find_children(QtWidgets.QToolBar, recursive=False)

load_window_state(recursive: bool = False) -> bool

Source code in prettyqt\widgets\mainwindow.py
def load_window_state(self, recursive: bool = False) -> bool:
    settings = core.Settings()
    name = self.get_id()
    geom = settings.get(f"{name}.geometry")
    state = settings.get(f"{name}.state")
    restored = False
    if geom is not None and state is not None:
        try:
            logger.debug(f"Loading window state for {self.windowTitle()!r}...")
            self.restoreGeometry(geom)
            if isinstance(state, str):
                state = state.encode()
            self.restoreState(state)
            restored = True
        except TypeError:
            logger.error("Wrong type for window state. Probably Qt binding switch?")
    if recursive:
        for window in self.find_children(MainWindow, recursive=True):
            if window.get_id():
                window.load_window_state()
    return restored

remove_dockwidgets(dockwidgets: Sequence[QtWidgets.QDockWidget])

Source code in prettyqt\widgets\mainwindow.py
def remove_dockwidgets(self, dockwidgets: Sequence[QtWidgets.QDockWidget]):
    for i in dockwidgets:
        self.removeDockWidget(i)

save_window_state(recursive: bool = False)

Save current window state as QSetting.

Parameters:

Name Type Description Default
recursive bool

Description

False
Source code in prettyqt\widgets\mainwindow.py
def save_window_state(self, recursive: bool = False):
    """Save current window state as QSetting.

    Args:
        recursive (bool, optional): Description
    """
    settings = core.Settings()
    name = self.get_id()
    logger.debug(f"Saving window state for {self.windowTitle()!r}...")
    settings[f"{name}.geometry"] = self.saveGeometry()
    settings[f"{name}.state"] = self.saveState()
    if recursive:
        for window in self.find_children(MainWindow, recursive=True):
            if window.get_id():
                window.save_window_state()

set_widget(widget: QtWidgets.QWidget | None)

Source code in prettyqt\widgets\mainwindow.py
def set_widget(self, widget: QtWidgets.QWidget | None):
    if widget is None:
        self.takeCentralWidget()
    else:
        self.setCentralWidget(widget)

show_blocking()

Source code in prettyqt\widgets\mainwindow.py
def show_blocking(self):
    self.set_modality("application")
    self.show()

MdiArea

Bases: widgets.AbstractScrollAreaMixin, QtWidgets.QMdiArea

Source code in prettyqt\widgets\mdiarea.py
class MdiArea(widgets.AbstractScrollAreaMixin, QtWidgets.QMdiArea):
    def __add__(self, other: QtWidgets.QWidget):
        self.add(other)
        return self

    def set_view_mode(self, mode: ViewModeStr):
        """Set view mode for the MDI area.

        Args:
            mode: view mode to use

        Raises:
            InvalidParamError: view mode does not exist
        """
        if mode not in VIEW_MODE:
            raise InvalidParamError(mode, VIEW_MODE)
        self.setViewMode(VIEW_MODE[mode])

    def get_view_mode(self) -> ViewModeStr:
        """Return current view mode.

        Returns:
            view mode
        """
        return VIEW_MODE.inverse[self.viewMode()]

    def set_window_order(self, mode: WindowOrderStr):
        """Set the window order behaviour for the MDI area.

        Args:
            mode: window order behaviour to use

        Raises:
            InvalidParamError: window order mode not existing.
        """
        if mode not in WINDOW_ORDER:
            raise InvalidParamError(mode, WINDOW_ORDER)
        self.setActivationOrder(WINDOW_ORDER[mode])

    def get_window_order(self) -> WindowOrderStr:
        """Return current window order.

        Returns:
            view mode
        """
        return WINDOW_ORDER.inverse[self.activationOrder()]

    def set_tab_position(self, position: TabPositionStr):
        """Set tab position for the MDI area.

        Args:
            position: tabs position to use

        Raises:
            InvalidParamError: tab position does not exist
        """
        if position not in TAB_POSITION:
            raise InvalidParamError(position, TAB_POSITION)
        self.setTabPosition(TAB_POSITION[position])

    def get_tab_position(self) -> TabPositionStr:
        """Return current tab position.

        Returns:
            tab position
        """
        return TAB_POSITION.inverse[self.tabPosition()]

    def set_background(
        self,
        brush_or_color: datatypes.ColorAndBrushType,
        pattern: constants.BrushStyleStr = "solid",
    ):
        if isinstance(brush_or_color, QtGui.QBrush):
            brush = brush_or_color
        else:
            color = colors.get_color(brush_or_color)
            brush = gui.Brush(color, constants.BRUSH_STYLE[pattern])
        self.setBackground(brush)

    def get_background(self) -> gui.Brush:
        return gui.Brush(self.background())

    def add(self, *item: QtWidgets.QWidget):
        for i in item:
            if not isinstance(i, QtWidgets.QMdiSubWindow):
                widget = widgets.MdiSubWindow()
                widget.setWidget(i)
                self.addSubWindow(widget)
            else:
                self.addSubWindow(i)

__add__(other: QtWidgets.QWidget)

Source code in prettyqt\widgets\mdiarea.py
def __add__(self, other: QtWidgets.QWidget):
    self.add(other)
    return self

add(*item: QtWidgets.QWidget)

Source code in prettyqt\widgets\mdiarea.py
def add(self, *item: QtWidgets.QWidget):
    for i in item:
        if not isinstance(i, QtWidgets.QMdiSubWindow):
            widget = widgets.MdiSubWindow()
            widget.setWidget(i)
            self.addSubWindow(widget)
        else:
            self.addSubWindow(i)

get_background() -> gui.Brush

Source code in prettyqt\widgets\mdiarea.py
def get_background(self) -> gui.Brush:
    return gui.Brush(self.background())

get_tab_position() -> TabPositionStr

Return current tab position.

Returns:

Type Description
TabPositionStr

tab position

Source code in prettyqt\widgets\mdiarea.py
def get_tab_position(self) -> TabPositionStr:
    """Return current tab position.

    Returns:
        tab position
    """
    return TAB_POSITION.inverse[self.tabPosition()]

get_view_mode() -> ViewModeStr

Return current view mode.

Returns:

Type Description
ViewModeStr

view mode

Source code in prettyqt\widgets\mdiarea.py
def get_view_mode(self) -> ViewModeStr:
    """Return current view mode.

    Returns:
        view mode
    """
    return VIEW_MODE.inverse[self.viewMode()]

get_window_order() -> WindowOrderStr

Return current window order.

Returns:

Type Description
WindowOrderStr

view mode

Source code in prettyqt\widgets\mdiarea.py
def get_window_order(self) -> WindowOrderStr:
    """Return current window order.

    Returns:
        view mode
    """
    return WINDOW_ORDER.inverse[self.activationOrder()]

set_background(brush_or_color: datatypes.ColorAndBrushType, pattern: constants.BrushStyleStr = 'solid')

Source code in prettyqt\widgets\mdiarea.py
def set_background(
    self,
    brush_or_color: datatypes.ColorAndBrushType,
    pattern: constants.BrushStyleStr = "solid",
):
    if isinstance(brush_or_color, QtGui.QBrush):
        brush = brush_or_color
    else:
        color = colors.get_color(brush_or_color)
        brush = gui.Brush(color, constants.BRUSH_STYLE[pattern])
    self.setBackground(brush)

set_tab_position(position: TabPositionStr)

Set tab position for the MDI area.

Parameters:

Name Type Description Default
position TabPositionStr

tabs position to use

required

Raises:

Type Description
InvalidParamError

tab position does not exist

Source code in prettyqt\widgets\mdiarea.py
def set_tab_position(self, position: TabPositionStr):
    """Set tab position for the MDI area.

    Args:
        position: tabs position to use

    Raises:
        InvalidParamError: tab position does not exist
    """
    if position not in TAB_POSITION:
        raise InvalidParamError(position, TAB_POSITION)
    self.setTabPosition(TAB_POSITION[position])

set_view_mode(mode: ViewModeStr)

Set view mode for the MDI area.

Parameters:

Name Type Description Default
mode ViewModeStr

view mode to use

required

Raises:

Type Description
InvalidParamError

view mode does not exist

Source code in prettyqt\widgets\mdiarea.py
def set_view_mode(self, mode: ViewModeStr):
    """Set view mode for the MDI area.

    Args:
        mode: view mode to use

    Raises:
        InvalidParamError: view mode does not exist
    """
    if mode not in VIEW_MODE:
        raise InvalidParamError(mode, VIEW_MODE)
    self.setViewMode(VIEW_MODE[mode])

set_window_order(mode: WindowOrderStr)

Set the window order behaviour for the MDI area.

Parameters:

Name Type Description Default
mode WindowOrderStr

window order behaviour to use

required

Raises:

Type Description
InvalidParamError

window order mode not existing.

Source code in prettyqt\widgets\mdiarea.py
def set_window_order(self, mode: WindowOrderStr):
    """Set the window order behaviour for the MDI area.

    Args:
        mode: window order behaviour to use

    Raises:
        InvalidParamError: window order mode not existing.
    """
    if mode not in WINDOW_ORDER:
        raise InvalidParamError(mode, WINDOW_ORDER)
    self.setActivationOrder(WINDOW_ORDER[mode])

MdiSubWindow

Bases: widgets.WidgetMixin, QtWidgets.QMdiSubWindow

Source code in prettyqt\widgets\mdisubwindow.py
class MdiSubWindow(widgets.WidgetMixin, QtWidgets.QMdiSubWindow):
    def serialize_fields(self):
        return dict(
            keyboard_single_step=self.keyboardSingleStep(),
            keyboard_page_step=self.keyboardPageStep(),
        )

serialize_fields()

Source code in prettyqt\widgets\mdisubwindow.py
def serialize_fields(self):
    return dict(
        keyboard_single_step=self.keyboardSingleStep(),
        keyboard_page_step=self.keyboardPageStep(),
    )

Menu

Bases: MenuMixin, QtWidgets.QMenu

Source code in prettyqt\widgets\menu.py
class Menu(MenuMixin, QtWidgets.QMenu):
    pass

MenuBar

Bases: widgets.WidgetMixin, QtWidgets.QMenuBar

Source code in prettyqt\widgets\menubar.py
class MenuBar(widgets.WidgetMixin, QtWidgets.QMenuBar):
    def __add__(self, other: QtWidgets.QAction | QtWidgets.QMenu):
        self.add(other)
        return self

    def serialize_fields(self):
        return dict(
            default_up=self.isDefaultUp(),
            native_menu_bar=self.isNativeMenuBar(),
        )

    def add_action(self, action: QtWidgets.QAction | str) -> QtWidgets.QAction:
        if isinstance(action, str):
            action = widgets.Action(parent=self, text=action)
        self.addAction(action)
        return action

    @overload
    def add_menu(self, menu_or_str: str) -> widgets.Menu:
        ...

    @overload
    def add_menu(self, menu_or_str: QtWidgets.QMenu) -> widgets.Action:
        ...

    def add_menu(self, menu_or_str):
        action = widgets.Action(parent=self)
        if isinstance(menu_or_str, str):
            menu = widgets.Menu(menu_or_str)
            action.set_text(menu_or_str)
            action.set_menu(menu)
            self.addAction(action)
            return menu
        else:
            action.set_menu(menu_or_str)
            action.set_text(menu_or_str.title())
            self.addAction(action)
            return action

    def add_separator(self):
        self.addSeparator()

    def add(self, *items: QtWidgets.QMenu | QtWidgets.QAction):
        for i in items:
            if isinstance(i, QtWidgets.QMenu):
                action = widgets.Action(parent=self)
                action.set_text(i.title())
                action.set_menu(i)
                self.addAction(action)
            else:
                self.addAction(i)

    def set_corner_widget(
        self,
        widget: QtWidgets.QWidget,
        corner: Literal["top_right", "top_left"] = "top_right",
    ):
        match corner:
            case "top_left":
                self.setCornerWidget(widget, QtCore.Qt.Corner.TopLeftCorner)
            case "top_right":
                self.setCornerWidget(widget, QtCore.Qt.Corner.TopRightCorner)
            case _:
                raise ValueError(corner)

    def get_corner_widget(
        self,
        corner: Literal["top_right", "top_left"] = "top_right",
    ) -> QtWidgets.QWidget:
        match corner:
            case "top_left":
                return self.cornerWidget(QtCore.Qt.Corner.TopLeftCorner)
            case "top_right":
                return self.cornerWidget(QtCore.Qt.Corner.TopRightCorner)
            case _:
                raise ValueError(corner)

__add__(other: QtWidgets.QAction | QtWidgets.QMenu)

Source code in prettyqt\widgets\menubar.py
def __add__(self, other: QtWidgets.QAction | QtWidgets.QMenu):
    self.add(other)
    return self

add(*items: QtWidgets.QMenu | QtWidgets.QAction)

Source code in prettyqt\widgets\menubar.py
def add(self, *items: QtWidgets.QMenu | QtWidgets.QAction):
    for i in items:
        if isinstance(i, QtWidgets.QMenu):
            action = widgets.Action(parent=self)
            action.set_text(i.title())
            action.set_menu(i)
            self.addAction(action)
        else:
            self.addAction(i)

add_action(action: QtWidgets.QAction | str) -> QtWidgets.QAction

Source code in prettyqt\widgets\menubar.py
def add_action(self, action: QtWidgets.QAction | str) -> QtWidgets.QAction:
    if isinstance(action, str):
        action = widgets.Action(parent=self, text=action)
    self.addAction(action)
    return action

add_menu(menu_or_str)

Source code in prettyqt\widgets\menubar.py
def add_menu(self, menu_or_str):
    action = widgets.Action(parent=self)
    if isinstance(menu_or_str, str):
        menu = widgets.Menu(menu_or_str)
        action.set_text(menu_or_str)
        action.set_menu(menu)
        self.addAction(action)
        return menu
    else:
        action.set_menu(menu_or_str)
        action.set_text(menu_or_str.title())
        self.addAction(action)
        return action

add_separator()

Source code in prettyqt\widgets\menubar.py
def add_separator(self):
    self.addSeparator()

get_corner_widget(corner: Literal['top_right', 'top_left'] = 'top_right') -> QtWidgets.QWidget

Source code in prettyqt\widgets\menubar.py
def get_corner_widget(
    self,
    corner: Literal["top_right", "top_left"] = "top_right",
) -> QtWidgets.QWidget:
    match corner:
        case "top_left":
            return self.cornerWidget(QtCore.Qt.Corner.TopLeftCorner)
        case "top_right":
            return self.cornerWidget(QtCore.Qt.Corner.TopRightCorner)
        case _:
            raise ValueError(corner)

serialize_fields()

Source code in prettyqt\widgets\menubar.py
def serialize_fields(self):
    return dict(
        default_up=self.isDefaultUp(),
        native_menu_bar=self.isNativeMenuBar(),
    )

set_corner_widget(widget: QtWidgets.QWidget, corner: Literal['top_right', 'top_left'] = 'top_right')

Source code in prettyqt\widgets\menubar.py
def set_corner_widget(
    self,
    widget: QtWidgets.QWidget,
    corner: Literal["top_right", "top_left"] = "top_right",
):
    match corner:
        case "top_left":
            self.setCornerWidget(widget, QtCore.Qt.Corner.TopLeftCorner)
        case "top_right":
            self.setCornerWidget(widget, QtCore.Qt.Corner.TopRightCorner)
        case _:
            raise ValueError(corner)

MessageBox

Bases: widgets.DialogMixin, QtWidgets.QMessageBox

Source code in prettyqt\widgets\messagebox.py
class MessageBox(widgets.DialogMixin, QtWidgets.QMessageBox):
    def __init__(
        self,
        icon: datatypes.IconType | IconStr = None,
        title: str = "",
        text: str = "",
        informative_text: str = "",
        details: str = "",
        buttons: list[ButtonStr] | None = None,
        parent: QtWidgets.QWidget | None = None,
    ):
        super().__init__(parent)
        self.set_icon(icon)
        self.setText(text)
        self.setInformativeText(informative_text)
        self.setWindowTitle(title)
        self.setWindowFlags(
            QtCore.Qt.WindowType.Dialog  # type: ignore
            | QtCore.Qt.WindowType.WindowTitleHint
            | QtCore.Qt.WindowType.CustomizeWindowHint
        )
        self.setDetailedText(details)
        if isinstance(buttons, list):
            for b in buttons:
                self.add_button(b)

    def serialize_fields(self):
        return dict(
            icon=self.get_icon(),
            detailed_text=self.detailedText(),
            icon_pixmap=self.get_icon_pixmap(),
            informative_text=self.informativeText(),
            text=self.text(),
            text_format=self.get_text_format(),
        )

    @classmethod
    def message(
        cls,
        text: str,
        title: str = "",
        icon: datatypes.IconType = None,
        detail_text: str | None = None,
    ) -> str:
        m = cls("none", title, text)
        m.set_icon(icon)
        if detail_text is not None:
            m.setDetailedText(detail_text)
        return m.show_blocking()

    @classmethod
    def show_exception(cls, exception: Exception):
        exctype, value = sys.exc_info()[:2]
        tb = traceback.format_exc()
        dlg = cls(text=str(value), title=str(exctype), icon="critical", details=tb)
        dlg.show_blocking()

    def set_icon(self, icon: datatypes.IconType | IconStr):
        if icon in ICONS:
            self.setIcon(ICONS[icon])
        else:
            ico = iconprovider.get_icon(icon)
            self.setIconPixmap(ico.get_pixmap(size=64))

    def show_blocking(self) -> ButtonStr:
        return BUTTONS.inverse[self.main_loop()]

    def get_icon_pixmap(self) -> gui.Pixmap | None:
        pix = self.iconPixmap()
        return None if pix.isNull() else gui.Pixmap(pix)

    def get_standard_buttons(self) -> list[ButtonStr]:
        return BUTTONS.get_list(self.standardButtons())

    def add_button(self, button: ButtonStr) -> QtWidgets.QPushButton:
        """Add a default button.

        Args:
            button: button to add

        Returns:
            created button

        Raises:
            InvalidParamError: Button type not available
        """
        if button not in BUTTONS:
            raise InvalidParamError(button, BUTTONS)
        return self.addButton(BUTTONS[button])

    # @classmethod
    # def show_exception(cls, exception):
    #     header = str(exception[0])
    #     error_text = str(exception[1])
    #     widgets.MessageBox.message(error_text, header, "mdi.exclamation")

    def set_text_format(self, text_format: TextFormatStr):
        """Set the text format.

        Args:
            text_format: text format to use

        Raises:
            InvalidParamError: text format does not exist
        """
        if text_format not in TEXT_FORMAT:
            raise InvalidParamError(text_format, TEXT_FORMAT)
        self.setTextFormat(TEXT_FORMAT[text_format])

    def get_text_format(self) -> TextFormatStr:
        """Return current text format.

        Returns:
            text format
        """
        return TEXT_FORMAT.inverse[self.textFormat()]

    def set_escape_button(self, button: ButtonStr | QtWidgets.QAbstractButton):
        if isinstance(button, QtWidgets.QAbstractButton):
            self.setEscapeButton(button)
        else:
            self.setEscapeButton(BUTTONS[button])

    def set_default_button(self, button: ButtonStr | QtWidgets.QPushButton):
        if isinstance(button, QtWidgets.QPushButton):
            self.setDefaultButton(button)
        else:
            self.setDefaultButton(BUTTONS[button])

__init__(icon: datatypes.IconType | IconStr = None, title: str = '', text: str = '', informative_text: str = '', details: str = '', buttons: list[ButtonStr] | None = None, parent: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\messagebox.py
def __init__(
    self,
    icon: datatypes.IconType | IconStr = None,
    title: str = "",
    text: str = "",
    informative_text: str = "",
    details: str = "",
    buttons: list[ButtonStr] | None = None,
    parent: QtWidgets.QWidget | None = None,
):
    super().__init__(parent)
    self.set_icon(icon)
    self.setText(text)
    self.setInformativeText(informative_text)
    self.setWindowTitle(title)
    self.setWindowFlags(
        QtCore.Qt.WindowType.Dialog  # type: ignore
        | QtCore.Qt.WindowType.WindowTitleHint
        | QtCore.Qt.WindowType.CustomizeWindowHint
    )
    self.setDetailedText(details)
    if isinstance(buttons, list):
        for b in buttons:
            self.add_button(b)

add_button(button: ButtonStr) -> QtWidgets.QPushButton

Add a default button.

Parameters:

Name Type Description Default
button ButtonStr

button to add

required

Returns:

Type Description
QtWidgets.QPushButton

created button

Raises:

Type Description
InvalidParamError

Button type not available

Source code in prettyqt\widgets\messagebox.py
def add_button(self, button: ButtonStr) -> QtWidgets.QPushButton:
    """Add a default button.

    Args:
        button: button to add

    Returns:
        created button

    Raises:
        InvalidParamError: Button type not available
    """
    if button not in BUTTONS:
        raise InvalidParamError(button, BUTTONS)
    return self.addButton(BUTTONS[button])

get_icon_pixmap() -> gui.Pixmap | None

Source code in prettyqt\widgets\messagebox.py
def get_icon_pixmap(self) -> gui.Pixmap | None:
    pix = self.iconPixmap()
    return None if pix.isNull() else gui.Pixmap(pix)

get_standard_buttons() -> list[ButtonStr]

Source code in prettyqt\widgets\messagebox.py
def get_standard_buttons(self) -> list[ButtonStr]:
    return BUTTONS.get_list(self.standardButtons())

get_text_format() -> TextFormatStr

Return current text format.

Returns:

Type Description
TextFormatStr

text format

Source code in prettyqt\widgets\messagebox.py
def get_text_format(self) -> TextFormatStr:
    """Return current text format.

    Returns:
        text format
    """
    return TEXT_FORMAT.inverse[self.textFormat()]

message(text: str, title: str = '', icon: datatypes.IconType = None, detail_text: str | None = None) -> str classmethod

Source code in prettyqt\widgets\messagebox.py
@classmethod
def message(
    cls,
    text: str,
    title: str = "",
    icon: datatypes.IconType = None,
    detail_text: str | None = None,
) -> str:
    m = cls("none", title, text)
    m.set_icon(icon)
    if detail_text is not None:
        m.setDetailedText(detail_text)
    return m.show_blocking()

serialize_fields()

Source code in prettyqt\widgets\messagebox.py
def serialize_fields(self):
    return dict(
        icon=self.get_icon(),
        detailed_text=self.detailedText(),
        icon_pixmap=self.get_icon_pixmap(),
        informative_text=self.informativeText(),
        text=self.text(),
        text_format=self.get_text_format(),
    )

set_default_button(button: ButtonStr | QtWidgets.QPushButton)

Source code in prettyqt\widgets\messagebox.py
def set_default_button(self, button: ButtonStr | QtWidgets.QPushButton):
    if isinstance(button, QtWidgets.QPushButton):
        self.setDefaultButton(button)
    else:
        self.setDefaultButton(BUTTONS[button])

set_escape_button(button: ButtonStr | QtWidgets.QAbstractButton)

Source code in prettyqt\widgets\messagebox.py
def set_escape_button(self, button: ButtonStr | QtWidgets.QAbstractButton):
    if isinstance(button, QtWidgets.QAbstractButton):
        self.setEscapeButton(button)
    else:
        self.setEscapeButton(BUTTONS[button])

set_icon(icon: datatypes.IconType | IconStr)

Source code in prettyqt\widgets\messagebox.py
def set_icon(self, icon: datatypes.IconType | IconStr):
    if icon in ICONS:
        self.setIcon(ICONS[icon])
    else:
        ico = iconprovider.get_icon(icon)
        self.setIconPixmap(ico.get_pixmap(size=64))

set_text_format(text_format: TextFormatStr)

Set the text format.

Parameters:

Name Type Description Default
text_format TextFormatStr

text format to use

required

Raises:

Type Description
InvalidParamError

text format does not exist

Source code in prettyqt\widgets\messagebox.py
def set_text_format(self, text_format: TextFormatStr):
    """Set the text format.

    Args:
        text_format: text format to use

    Raises:
        InvalidParamError: text format does not exist
    """
    if text_format not in TEXT_FORMAT:
        raise InvalidParamError(text_format, TEXT_FORMAT)
    self.setTextFormat(TEXT_FORMAT[text_format])

show_blocking() -> ButtonStr

Source code in prettyqt\widgets\messagebox.py
def show_blocking(self) -> ButtonStr:
    return BUTTONS.inverse[self.main_loop()]

show_exception(exception: Exception) classmethod

Source code in prettyqt\widgets\messagebox.py
@classmethod
def show_exception(cls, exception: Exception):
    exctype, value = sys.exc_info()[:2]
    tb = traceback.format_exc()
    dlg = cls(text=str(value), title=str(exctype), icon="critical", details=tb)
    dlg.show_blocking()

PanGesture

Bases: widgets.GestureMixin, QtWidgets.QPanGesture

Source code in prettyqt\widgets\pangesture.py
class PanGesture(widgets.GestureMixin, QtWidgets.QPanGesture):
    def get_delta(self) -> core.PointF:
        return core.PointF(self.delta())

    def get_last_offset(self) -> core.PointF:
        return core.PointF(self.lastOffset())

    def get_offset(self) -> core.PointF:
        return core.PointF(self.offset())

get_delta() -> core.PointF

Source code in prettyqt\widgets\pangesture.py
def get_delta(self) -> core.PointF:
    return core.PointF(self.delta())

get_last_offset() -> core.PointF

Source code in prettyqt\widgets\pangesture.py
def get_last_offset(self) -> core.PointF:
    return core.PointF(self.lastOffset())

get_offset() -> core.PointF

Source code in prettyqt\widgets\pangesture.py
def get_offset(self) -> core.PointF:
    return core.PointF(self.offset())

PinchGesture

Bases: widgets.GestureMixin, QtWidgets.QPinchGesture

Source code in prettyqt\widgets\pinchgesture.py
class PinchGesture(widgets.GestureMixin, QtWidgets.QPinchGesture):
    def get_start_center_point(self) -> core.PointF:
        return core.PointF(self.startCenterPoint())

    def get_center_point(self) -> core.PointF:
        return core.PointF(self.centerPoint())

    def get_last_center_point(self) -> core.PointF:
        return core.PointF(self.lastCenterPoint())

    def get_change_flags(self) -> list[ChangeFlagStr]:
        return CHANGE_FLAGS.get_list(self.changeFlags())

    def set_change_flags(self, **kwargs):
        val = QtWidgets.QPinchGesture.ChangeFlag(0)
        for k, v in kwargs.items():
            if v is True:
                val |= CHANGE_FLAGS[k]
        flag = QtWidgets.QPinchGesture.ChangeFlag(val)  # type: ignore
        self.setChangeFlags(flag)  # type: ignore

    def get_total_change_flags(self) -> list[ChangeFlagStr]:
        return CHANGE_FLAGS.get_list(self.totalChangeFlags())

    def set_total_change_flags(self, **kwargs):
        val = QtWidgets.QPinchGesture.ChangeFlag(0)
        for k, v in kwargs.items():
            if v is True:
                val |= CHANGE_FLAGS[k]
        flag = QtWidgets.QPinchGesture.ChangeFlag(val)  # type: ignore
        self.setTotalChangeFlags(flag)  # type: ignore

get_center_point() -> core.PointF

Source code in prettyqt\widgets\pinchgesture.py
def get_center_point(self) -> core.PointF:
    return core.PointF(self.centerPoint())

get_change_flags() -> list[ChangeFlagStr]

Source code in prettyqt\widgets\pinchgesture.py
def get_change_flags(self) -> list[ChangeFlagStr]:
    return CHANGE_FLAGS.get_list(self.changeFlags())

get_last_center_point() -> core.PointF

Source code in prettyqt\widgets\pinchgesture.py
def get_last_center_point(self) -> core.PointF:
    return core.PointF(self.lastCenterPoint())

get_start_center_point() -> core.PointF

Source code in prettyqt\widgets\pinchgesture.py
def get_start_center_point(self) -> core.PointF:
    return core.PointF(self.startCenterPoint())

get_total_change_flags() -> list[ChangeFlagStr]

Source code in prettyqt\widgets\pinchgesture.py
def get_total_change_flags(self) -> list[ChangeFlagStr]:
    return CHANGE_FLAGS.get_list(self.totalChangeFlags())

set_change_flags(**kwargs)

Source code in prettyqt\widgets\pinchgesture.py
def set_change_flags(self, **kwargs):
    val = QtWidgets.QPinchGesture.ChangeFlag(0)
    for k, v in kwargs.items():
        if v is True:
            val |= CHANGE_FLAGS[k]
    flag = QtWidgets.QPinchGesture.ChangeFlag(val)  # type: ignore
    self.setChangeFlags(flag)  # type: ignore

set_total_change_flags(**kwargs)

Source code in prettyqt\widgets\pinchgesture.py
def set_total_change_flags(self, **kwargs):
    val = QtWidgets.QPinchGesture.ChangeFlag(0)
    for k, v in kwargs.items():
        if v is True:
            val |= CHANGE_FLAGS[k]
    flag = QtWidgets.QPinchGesture.ChangeFlag(val)  # type: ignore
    self.setTotalChangeFlags(flag)  # type: ignore

PlainTextDocumentLayout

Bases: gui.AbstractTextDocumentLayoutMixin, QtWidgets.QPlainTextDocumentLayout

Source code in prettyqt\widgets\plaintextdocumentlayout.py
class PlainTextDocumentLayout(
    gui.AbstractTextDocumentLayoutMixin, QtWidgets.QPlainTextDocumentLayout
):
    def serialize_fields(self):
        return dict(cursor_width=self.cursorWidth())

serialize_fields()

Source code in prettyqt\widgets\plaintextdocumentlayout.py
def serialize_fields(self):
    return dict(cursor_width=self.cursorWidth())

PlainTextEdit

Bases: PlainTextEditMixin, QtWidgets.QPlainTextEdit

Source code in prettyqt\widgets\plaintextedit.py
class PlainTextEdit(PlainTextEditMixin, QtWidgets.QPlainTextEdit):
    pass

PlainTextEditMixin

Bases: widgets.AbstractScrollAreaMixin

Source code in prettyqt\widgets\plaintextedit.py
class PlainTextEditMixin(widgets.AbstractScrollAreaMixin):
    value_changed = core.Signal()

    def __init__(
        self,
        text: str = "",
        parent: QtWidgets.QWidget | None = None,
        read_only: bool = False,
    ):
        super().__init__(parent)
        self._allow_wheel_zoom = False
        self.validator: QtGui.QValidator | None = None
        self.textChanged.connect(self._on_value_change)
        self.set_read_only(read_only)
        doc = gui.TextDocument(self)
        layout = widgets.PlainTextDocumentLayout(doc)
        doc.setDocumentLayout(layout)
        self.setDocument(doc)
        self.set_text(text)

    def __add__(self, other: str):
        self.append_text(other)
        return self

    def wheelEvent(self, event):
        """Handle wheel event for zooming."""
        if not self._allow_wheel_zoom:
            return None
        if event.modifiers() & constants.CTRL_MOD:
            self.zoomIn() if event.angleDelta().y() > 0 else self.zoomOut()
        else:
            super().wheelEvent(event)

    def allow_wheel_zoom(self, do_zoom: bool = True):
        self._allow_wheel_zoom = do_zoom

    def goto_line(self, line_no: int):
        doc = self.document()
        lines = doc.blockCount()
        assert 1 <= line_no <= lines
        pos = doc.findBlockByLineNumber(line_no - 1).position()
        with self.current_cursor() as text_cursor:
            text_cursor.setPosition(pos)

    def get_selected_text(self) -> str:
        if self.textCursor().hasSelection():
            return self.textCursor().selectedText()
        else:
            return ""

    def get_current_line(self) -> int:
        return self.textCursor().blockNumber()

    def get_selected_rows(self) -> tuple[int, int]:
        start = self.textCursor().selectionStart()
        end = self.textCursor().selectionEnd()
        start_block_id = self.document().findBlock(start).blockNumber()
        end_block_id = self.document().findBlock(end).blockNumber()

        return (start_block_id, end_block_id)

    @contextlib.contextmanager
    def create_cursor(self) -> Iterator[gui.TextCursor]:
        cursor = gui.TextCursor(self.document())
        yield cursor
        self.setTextCursor(cursor)

    @contextlib.contextmanager
    def current_cursor(self) -> Iterator[gui.TextCursor]:
        cursor = gui.TextCursor(self.textCursor())
        yield cursor
        self.setTextCursor(cursor)

    def get_text_cursor(self) -> gui.TextCursor:
        return gui.TextCursor(self.textCursor())

    def move_cursor(
        self,
        operation: gui.textcursor.MoveOperationStr,
        mode: gui.textcursor.MoveModeStr = "move",
    ):
        self.moveCursor(
            gui.textcursor.MOVE_OPERATION[operation], gui.textcursor.MOVE_MODE[mode]
        )

    def append_text(self, text: str, newline: bool = True):
        if newline:
            self.appendPlainText(text)
        else:
            self.move_cursor("end")
            self.insertPlainText(text)
            self.move_cursor("end")

    def set_text(self, text: str):
        self.setPlainText(text)

    def set_syntaxhighlighter(self, syntax: str, style: str | None = None):
        self._hl = syntaxhighlighters.PygmentsHighlighter(self.document(), syntax, style)

    def text(self) -> str:
        return self.toPlainText()

    def select_text(self, start: int, end: int):
        with self.create_cursor() as c:
            c.select_text(start, end)

    def set_read_only(self, value: bool = True):
        """Make the PlainTextEdit read-only.

        Args:
            value: True, for read-only, otherwise False
        """
        self.setReadOnly(value)

    def show_whitespace_and_tabs(self, show: bool):
        """Set show white spaces flag."""
        doc = self.document()
        options = doc.defaultTextOption()
        flag = QtGui.QTextOption.Flag.ShowTabsAndSpaces
        if show:
            options.setFlags(options.flags() | flag)  # type: ignore
        else:
            options.setFlags(options.flags() & ~flag)  # type: ignore
        doc.setDefaultTextOption(options)

    def highlight_current_line(self, color: datatypes.ColorType = None):
        if color is None:
            color = self.get_palette().get_color("highlight")
        else:
            color = colors.get_color(color)
        extra_selections = []

        if not self.isReadOnly():
            selection = widgets.TextEdit.ExtraSelection()
            selection.format.setBackground(color)
            prop = QtGui.QTextFormat.Property.FullWidthSelection
            selection.format.setProperty(prop, True)
            selection.cursor = self.textCursor()
            selection.cursor.clearSelection()
            extra_selections.append(selection)

        self.setExtraSelections(extra_selections)

    @deprecated(reason="This method is deprecated, use set_word_wrap_mode instead.")
    def set_wrap_mode(self, mode: gui.textoption.WordWrapModeStr):
        self.set_word_wrap_mode(mode)

    def set_word_wrap_mode(self, mode: gui.textoption.WordWrapModeStr):
        """Set word wrap mode.

        Args:
            mode: word wrap mode to use

        Raises:
            InvalidParamError: wrap mode does not exist
        """
        if mode not in gui.textoption.WORD_WRAP_MODE:
            raise InvalidParamError(mode, gui.textoption.WORD_WRAP_MODE)
        self.setWordWrapMode(gui.textoption.WORD_WRAP_MODE[mode])

    @deprecated(reason="This method is deprecated, use get_word_wrap_mode instead.")
    def get_wrap_mode(self) -> gui.textoption.WordWrapModeStr:
        return self.get_word_wrap_mode()

    def get_word_wrap_mode(self) -> gui.textoption.WordWrapModeStr:
        """Get the current word wrap mode.

        Returns:
            Word wrap mode
        """
        return gui.textoption.WORD_WRAP_MODE.inverse[self.wordWrapMode()]

    def set_line_wrap_mode(self, mode: LineWrapModeStr):
        """Set line wrap mode.

        Args:
            mode: line wrap mode to use

        Raises:
            InvalidParamError: line wrap mode does not exist
        """
        if mode not in LINE_WRAP_MODE:
            raise InvalidParamError(mode, LINE_WRAP_MODE)
        self.setLineWrapMode(LINE_WRAP_MODE[mode])

    def get_line_wrap_mode(self) -> LineWrapModeStr:
        """Get the current wrap mode.

        Returns:
            Wrap mode
        """
        return LINE_WRAP_MODE.inverse[self.lineWrapMode()]

    def _on_value_change(self):
        self.value_changed.emit()
        if self.validator is not None:
            self._set_validation_color()

    def _set_validation_color(self, state: bool = True):
        color = None if self.is_valid() else "orange"
        self.set_background_color(color)

    def set_validator(self, validator: QtGui.QValidator | None):
        self.validator = validator
        self._set_validation_color()

    def set_regex_validator(self, regex: str, flags=0) -> gui.RegularExpressionValidator:
        validator = gui.RegularExpressionValidator(self)
        validator.set_regex(regex, flags)
        self.set_validator(validator)
        return validator

    def is_valid(self) -> bool:
        if self.validator is None:
            return True
        val = self.validator.validate(self.text(), 0)
        return val[0] == self.validator.State.Acceptable

    def set_value(self, value: str):
        self.setPlainText(value)

    def get_value(self) -> str:
        return self.text()

validator: QtGui.QValidator | None = None instance-attribute

value_changed = core.Signal() class-attribute

__add__(other: str)

Source code in prettyqt\widgets\plaintextedit.py
def __add__(self, other: str):
    self.append_text(other)
    return self

__init__(text: str = '', parent: QtWidgets.QWidget | None = None, read_only: bool = False)

Source code in prettyqt\widgets\plaintextedit.py
def __init__(
    self,
    text: str = "",
    parent: QtWidgets.QWidget | None = None,
    read_only: bool = False,
):
    super().__init__(parent)
    self._allow_wheel_zoom = False
    self.validator: QtGui.QValidator | None = None
    self.textChanged.connect(self._on_value_change)
    self.set_read_only(read_only)
    doc = gui.TextDocument(self)
    layout = widgets.PlainTextDocumentLayout(doc)
    doc.setDocumentLayout(layout)
    self.setDocument(doc)
    self.set_text(text)

allow_wheel_zoom(do_zoom: bool = True)

Source code in prettyqt\widgets\plaintextedit.py
def allow_wheel_zoom(self, do_zoom: bool = True):
    self._allow_wheel_zoom = do_zoom

append_text(text: str, newline: bool = True)

Source code in prettyqt\widgets\plaintextedit.py
def append_text(self, text: str, newline: bool = True):
    if newline:
        self.appendPlainText(text)
    else:
        self.move_cursor("end")
        self.insertPlainText(text)
        self.move_cursor("end")

create_cursor() -> Iterator[gui.TextCursor]

Source code in prettyqt\widgets\plaintextedit.py
@contextlib.contextmanager
def create_cursor(self) -> Iterator[gui.TextCursor]:
    cursor = gui.TextCursor(self.document())
    yield cursor
    self.setTextCursor(cursor)

current_cursor() -> Iterator[gui.TextCursor]

Source code in prettyqt\widgets\plaintextedit.py
@contextlib.contextmanager
def current_cursor(self) -> Iterator[gui.TextCursor]:
    cursor = gui.TextCursor(self.textCursor())
    yield cursor
    self.setTextCursor(cursor)

get_current_line() -> int

Source code in prettyqt\widgets\plaintextedit.py
def get_current_line(self) -> int:
    return self.textCursor().blockNumber()

get_line_wrap_mode() -> LineWrapModeStr

Get the current wrap mode.

Returns:

Type Description
LineWrapModeStr

Wrap mode

Source code in prettyqt\widgets\plaintextedit.py
def get_line_wrap_mode(self) -> LineWrapModeStr:
    """Get the current wrap mode.

    Returns:
        Wrap mode
    """
    return LINE_WRAP_MODE.inverse[self.lineWrapMode()]

get_selected_rows() -> tuple[int, int]

Source code in prettyqt\widgets\plaintextedit.py
def get_selected_rows(self) -> tuple[int, int]:
    start = self.textCursor().selectionStart()
    end = self.textCursor().selectionEnd()
    start_block_id = self.document().findBlock(start).blockNumber()
    end_block_id = self.document().findBlock(end).blockNumber()

    return (start_block_id, end_block_id)

get_selected_text() -> str

Source code in prettyqt\widgets\plaintextedit.py
def get_selected_text(self) -> str:
    if self.textCursor().hasSelection():
        return self.textCursor().selectedText()
    else:
        return ""

get_text_cursor() -> gui.TextCursor

Source code in prettyqt\widgets\plaintextedit.py
def get_text_cursor(self) -> gui.TextCursor:
    return gui.TextCursor(self.textCursor())

get_value() -> str

Source code in prettyqt\widgets\plaintextedit.py
def get_value(self) -> str:
    return self.text()

get_word_wrap_mode() -> gui.textoption.WordWrapModeStr

Get the current word wrap mode.

Returns:

Type Description
gui.textoption.WordWrapModeStr

Word wrap mode

Source code in prettyqt\widgets\plaintextedit.py
def get_word_wrap_mode(self) -> gui.textoption.WordWrapModeStr:
    """Get the current word wrap mode.

    Returns:
        Word wrap mode
    """
    return gui.textoption.WORD_WRAP_MODE.inverse[self.wordWrapMode()]

get_wrap_mode() -> gui.textoption.WordWrapModeStr

Source code in prettyqt\widgets\plaintextedit.py
@deprecated(reason="This method is deprecated, use get_word_wrap_mode instead.")
def get_wrap_mode(self) -> gui.textoption.WordWrapModeStr:
    return self.get_word_wrap_mode()

goto_line(line_no: int)

Source code in prettyqt\widgets\plaintextedit.py
def goto_line(self, line_no: int):
    doc = self.document()
    lines = doc.blockCount()
    assert 1 <= line_no <= lines
    pos = doc.findBlockByLineNumber(line_no - 1).position()
    with self.current_cursor() as text_cursor:
        text_cursor.setPosition(pos)

highlight_current_line(color: datatypes.ColorType = None)

Source code in prettyqt\widgets\plaintextedit.py
def highlight_current_line(self, color: datatypes.ColorType = None):
    if color is None:
        color = self.get_palette().get_color("highlight")
    else:
        color = colors.get_color(color)
    extra_selections = []

    if not self.isReadOnly():
        selection = widgets.TextEdit.ExtraSelection()
        selection.format.setBackground(color)
        prop = QtGui.QTextFormat.Property.FullWidthSelection
        selection.format.setProperty(prop, True)
        selection.cursor = self.textCursor()
        selection.cursor.clearSelection()
        extra_selections.append(selection)

    self.setExtraSelections(extra_selections)

is_valid() -> bool

Source code in prettyqt\widgets\plaintextedit.py
def is_valid(self) -> bool:
    if self.validator is None:
        return True
    val = self.validator.validate(self.text(), 0)
    return val[0] == self.validator.State.Acceptable

move_cursor(operation: gui.textcursor.MoveOperationStr, mode: gui.textcursor.MoveModeStr = 'move')

Source code in prettyqt\widgets\plaintextedit.py
def move_cursor(
    self,
    operation: gui.textcursor.MoveOperationStr,
    mode: gui.textcursor.MoveModeStr = "move",
):
    self.moveCursor(
        gui.textcursor.MOVE_OPERATION[operation], gui.textcursor.MOVE_MODE[mode]
    )

select_text(start: int, end: int)

Source code in prettyqt\widgets\plaintextedit.py
def select_text(self, start: int, end: int):
    with self.create_cursor() as c:
        c.select_text(start, end)

set_line_wrap_mode(mode: LineWrapModeStr)

Set line wrap mode.

Parameters:

Name Type Description Default
mode LineWrapModeStr

line wrap mode to use

required

Raises:

Type Description
InvalidParamError

line wrap mode does not exist

Source code in prettyqt\widgets\plaintextedit.py
def set_line_wrap_mode(self, mode: LineWrapModeStr):
    """Set line wrap mode.

    Args:
        mode: line wrap mode to use

    Raises:
        InvalidParamError: line wrap mode does not exist
    """
    if mode not in LINE_WRAP_MODE:
        raise InvalidParamError(mode, LINE_WRAP_MODE)
    self.setLineWrapMode(LINE_WRAP_MODE[mode])

set_read_only(value: bool = True)

Make the PlainTextEdit read-only.

Parameters:

Name Type Description Default
value bool

True, for read-only, otherwise False

True
Source code in prettyqt\widgets\plaintextedit.py
def set_read_only(self, value: bool = True):
    """Make the PlainTextEdit read-only.

    Args:
        value: True, for read-only, otherwise False
    """
    self.setReadOnly(value)

set_regex_validator(regex: str, flags = 0) -> gui.RegularExpressionValidator

Source code in prettyqt\widgets\plaintextedit.py
def set_regex_validator(self, regex: str, flags=0) -> gui.RegularExpressionValidator:
    validator = gui.RegularExpressionValidator(self)
    validator.set_regex(regex, flags)
    self.set_validator(validator)
    return validator

set_syntaxhighlighter(syntax: str, style: str | None = None)

Source code in prettyqt\widgets\plaintextedit.py
def set_syntaxhighlighter(self, syntax: str, style: str | None = None):
    self._hl = syntaxhighlighters.PygmentsHighlighter(self.document(), syntax, style)

set_text(text: str)

Source code in prettyqt\widgets\plaintextedit.py
def set_text(self, text: str):
    self.setPlainText(text)

set_validator(validator: QtGui.QValidator | None)

Source code in prettyqt\widgets\plaintextedit.py
def set_validator(self, validator: QtGui.QValidator | None):
    self.validator = validator
    self._set_validation_color()

set_value(value: str)

Source code in prettyqt\widgets\plaintextedit.py
def set_value(self, value: str):
    self.setPlainText(value)

set_word_wrap_mode(mode: gui.textoption.WordWrapModeStr)

Set word wrap mode.

Parameters:

Name Type Description Default
mode gui.textoption.WordWrapModeStr

word wrap mode to use

required

Raises:

Type Description
InvalidParamError

wrap mode does not exist

Source code in prettyqt\widgets\plaintextedit.py
def set_word_wrap_mode(self, mode: gui.textoption.WordWrapModeStr):
    """Set word wrap mode.

    Args:
        mode: word wrap mode to use

    Raises:
        InvalidParamError: wrap mode does not exist
    """
    if mode not in gui.textoption.WORD_WRAP_MODE:
        raise InvalidParamError(mode, gui.textoption.WORD_WRAP_MODE)
    self.setWordWrapMode(gui.textoption.WORD_WRAP_MODE[mode])

set_wrap_mode(mode: gui.textoption.WordWrapModeStr)

Source code in prettyqt\widgets\plaintextedit.py
@deprecated(reason="This method is deprecated, use set_word_wrap_mode instead.")
def set_wrap_mode(self, mode: gui.textoption.WordWrapModeStr):
    self.set_word_wrap_mode(mode)

show_whitespace_and_tabs(show: bool)

Set show white spaces flag.

Source code in prettyqt\widgets\plaintextedit.py
def show_whitespace_and_tabs(self, show: bool):
    """Set show white spaces flag."""
    doc = self.document()
    options = doc.defaultTextOption()
    flag = QtGui.QTextOption.Flag.ShowTabsAndSpaces
    if show:
        options.setFlags(options.flags() | flag)  # type: ignore
    else:
        options.setFlags(options.flags() & ~flag)  # type: ignore
    doc.setDefaultTextOption(options)

text() -> str

Source code in prettyqt\widgets\plaintextedit.py
def text(self) -> str:
    return self.toPlainText()

wheelEvent(event)

Handle wheel event for zooming.

Source code in prettyqt\widgets\plaintextedit.py
def wheelEvent(self, event):
    """Handle wheel event for zooming."""
    if not self._allow_wheel_zoom:
        return None
    if event.modifiers() & constants.CTRL_MOD:
        self.zoomIn() if event.angleDelta().y() > 0 else self.zoomOut()
    else:
        super().wheelEvent(event)

ProgressBar

Bases: widgets.WidgetMixin, QtWidgets.QProgressBar

Progress dialog.

wrapper for QtWidgets.QProgressBar

Source code in prettyqt\widgets\progressbar.py
class ProgressBar(widgets.WidgetMixin, QtWidgets.QProgressBar):
    """Progress dialog.

    wrapper for QtWidgets.QProgressBar
    """

    def __init__(
        self, text_visible: bool = True, parent: QtWidgets.QWidget | None = None
    ):
        super().__init__(parent=parent)
        self.setTextVisible(text_visible)

    def serialize_fields(self):
        return dict(
            alignment=self.get_alignment(),
            format=self.format(),
            # inverted_appearance=self.invertedAppearance(),
            minimum=self.minimum(),
            maximum=self.maximum(),
            orientation=self.get_orientation(),
            text=self.text(),
            # text_direction=self.get_text_direction(),
            text_visible=self.isTextVisible(),
            value=self.value(),
        )

    def set_alignment(self, alignment: constants.AlignmentStr):
        """Set the alignment of the layout.

        Args:
            alignment: alignment for the layout

        Raises:
            InvalidParamError: alignment does not exist
        """
        if alignment not in constants.ALIGNMENTS:
            raise InvalidParamError(alignment, constants.ALIGNMENTS)
        self.setAlignment(constants.ALIGNMENTS[alignment])

    def get_alignment(self) -> constants.AlignmentStr:
        """Return current alignment.

        Returns:
            alignment
        """
        return constants.ALIGNMENTS.inverse[self.alignment()]

    def set_text_direction(self, text_direction: TextDirectionStr):
        """Set the text direction of the layout.

        Args:
            text_direction: text direction for the layout

        Raises:
            InvalidParamError: text direction does not exist
        """
        if text_direction not in TEXT_DIRECTIONS:
            raise InvalidParamError(text_direction, TEXT_DIRECTIONS)
        self.setTextDirection(TEXT_DIRECTIONS[text_direction])

    def get_text_direction(self) -> TextDirectionStr:
        """Return current text direction.

        Returns:
            Text direction
        """
        return TEXT_DIRECTIONS.inverse[self.textDirection()]

    def set_orientation(self, orientation: constants.OrientationStr):
        """Set the orientation of the progress bar.

        Args:
            orientation: orientation for the progress bar

        Raises:
            InvalidParamError: orientation does not exist
        """
        if orientation not in constants.ORIENTATION:
            raise InvalidParamError(orientation, constants.ORIENTATION)
        self.setOrientation(constants.ORIENTATION[orientation])

    def get_orientation(self) -> constants.OrientationStr:
        """Return current orientation.

        Returns:
            orientation
        """
        return constants.ORIENTATION.inverse[self.orientation()]

    def set_range(self, start: int, end: int):
        self.setRange(start, end)

    def set_value(self, value: int):
        self.setValue(value)

    def get_value(self) -> int:
        return self.value()

__init__(text_visible: bool = True, parent: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\progressbar.py
def __init__(
    self, text_visible: bool = True, parent: QtWidgets.QWidget | None = None
):
    super().__init__(parent=parent)
    self.setTextVisible(text_visible)

get_alignment() -> constants.AlignmentStr

Return current alignment.

Returns:

Type Description
constants.AlignmentStr

alignment

Source code in prettyqt\widgets\progressbar.py
def get_alignment(self) -> constants.AlignmentStr:
    """Return current alignment.

    Returns:
        alignment
    """
    return constants.ALIGNMENTS.inverse[self.alignment()]

get_orientation() -> constants.OrientationStr

Return current orientation.

Returns:

Type Description
constants.OrientationStr

orientation

Source code in prettyqt\widgets\progressbar.py
def get_orientation(self) -> constants.OrientationStr:
    """Return current orientation.

    Returns:
        orientation
    """
    return constants.ORIENTATION.inverse[self.orientation()]

get_text_direction() -> TextDirectionStr

Return current text direction.

Returns:

Type Description
TextDirectionStr

Text direction

Source code in prettyqt\widgets\progressbar.py
def get_text_direction(self) -> TextDirectionStr:
    """Return current text direction.

    Returns:
        Text direction
    """
    return TEXT_DIRECTIONS.inverse[self.textDirection()]

get_value() -> int

Source code in prettyqt\widgets\progressbar.py
def get_value(self) -> int:
    return self.value()

serialize_fields()

Source code in prettyqt\widgets\progressbar.py
def serialize_fields(self):
    return dict(
        alignment=self.get_alignment(),
        format=self.format(),
        # inverted_appearance=self.invertedAppearance(),
        minimum=self.minimum(),
        maximum=self.maximum(),
        orientation=self.get_orientation(),
        text=self.text(),
        # text_direction=self.get_text_direction(),
        text_visible=self.isTextVisible(),
        value=self.value(),
    )

set_alignment(alignment: constants.AlignmentStr)

Set the alignment of the layout.

Parameters:

Name Type Description Default
alignment constants.AlignmentStr

alignment for the layout

required

Raises:

Type Description
InvalidParamError

alignment does not exist

Source code in prettyqt\widgets\progressbar.py
def set_alignment(self, alignment: constants.AlignmentStr):
    """Set the alignment of the layout.

    Args:
        alignment: alignment for the layout

    Raises:
        InvalidParamError: alignment does not exist
    """
    if alignment not in constants.ALIGNMENTS:
        raise InvalidParamError(alignment, constants.ALIGNMENTS)
    self.setAlignment(constants.ALIGNMENTS[alignment])

set_orientation(orientation: constants.OrientationStr)

Set the orientation of the progress bar.

Parameters:

Name Type Description Default
orientation constants.OrientationStr

orientation for the progress bar

required

Raises:

Type Description
InvalidParamError

orientation does not exist

Source code in prettyqt\widgets\progressbar.py
def set_orientation(self, orientation: constants.OrientationStr):
    """Set the orientation of the progress bar.

    Args:
        orientation: orientation for the progress bar

    Raises:
        InvalidParamError: orientation does not exist
    """
    if orientation not in constants.ORIENTATION:
        raise InvalidParamError(orientation, constants.ORIENTATION)
    self.setOrientation(constants.ORIENTATION[orientation])

set_range(start: int, end: int)

Source code in prettyqt\widgets\progressbar.py
def set_range(self, start: int, end: int):
    self.setRange(start, end)

set_text_direction(text_direction: TextDirectionStr)

Set the text direction of the layout.

Parameters:

Name Type Description Default
text_direction TextDirectionStr

text direction for the layout

required

Raises:

Type Description
InvalidParamError

text direction does not exist

Source code in prettyqt\widgets\progressbar.py
def set_text_direction(self, text_direction: TextDirectionStr):
    """Set the text direction of the layout.

    Args:
        text_direction: text direction for the layout

    Raises:
        InvalidParamError: text direction does not exist
    """
    if text_direction not in TEXT_DIRECTIONS:
        raise InvalidParamError(text_direction, TEXT_DIRECTIONS)
    self.setTextDirection(TEXT_DIRECTIONS[text_direction])

set_value(value: int)

Source code in prettyqt\widgets\progressbar.py
def set_value(self, value: int):
    self.setValue(value)

ProgressDialog

Bases: widgets.DialogMixin, QtWidgets.QProgressDialog

Progress dialog.

Wrapper for QtWidgets.QProgressDialog

Source code in prettyqt\widgets\progressdialog.py
class ProgressDialog(widgets.DialogMixin, QtWidgets.QProgressDialog):
    """Progress dialog.

    Wrapper for QtWidgets.QProgressDialog
    """

    def __init__(self, parent: QtWidgets.QWidget | None = None):
        super().__init__(parent=parent)

        progress_bar = widgets.ProgressBar()
        progress_bar.setRange(0, 0)
        progress_bar.setTextVisible(False)
        self.setBar(progress_bar)

        self.set_icon("mdi.timer-sand-empty")
        self.set_modality("application")
        self.set_flags(
            minimize=False, maximize=False, close=False, stay_on_top=True, window=True
        )
        self.setCancelButton(None)  # type: ignore
        self.cancel()

    def show_message(self, message: str):
        self.setLabelText(message)
        self.show()

__init__(parent: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\progressdialog.py
def __init__(self, parent: QtWidgets.QWidget | None = None):
    super().__init__(parent=parent)

    progress_bar = widgets.ProgressBar()
    progress_bar.setRange(0, 0)
    progress_bar.setTextVisible(False)
    self.setBar(progress_bar)

    self.set_icon("mdi.timer-sand-empty")
    self.set_modality("application")
    self.set_flags(
        minimize=False, maximize=False, close=False, stay_on_top=True, window=True
    )
    self.setCancelButton(None)  # type: ignore
    self.cancel()

show_message(message: str)

Source code in prettyqt\widgets\progressdialog.py
def show_message(self, message: str):
    self.setLabelText(message)
    self.show()

ProxyStyle

Bases: widgets.CommonStyleMixin, QtWidgets.QProxyStyle

Source code in prettyqt\widgets\proxystyle.py
class ProxyStyle(widgets.CommonStyleMixin, QtWidgets.QProxyStyle):
    pass

PushButton

Bases: PushButtonMixin, QtWidgets.QPushButton

Source code in prettyqt\widgets\pushbutton.py
class PushButton(PushButtonMixin, QtWidgets.QPushButton):
    pass

PushButtonMixin

Bases: widgets.AbstractButtonMixin

Source code in prettyqt\widgets\pushbutton.py
class PushButtonMixin(widgets.AbstractButtonMixin):
    value_changed = core.Signal(bool)

    def __init__(
        self,
        label: str | None = None,
        parent: QtWidgets.QWidget | None = None,
        callback: Callable | None = None,
    ):
        if label is None:
            label = ""
        super().__init__(label, parent)
        if callback:
            self.clicked.connect(callback)
        self.toggled.connect(self.value_changed)

value_changed = core.Signal(bool) class-attribute

__init__(label: str | None = None, parent: QtWidgets.QWidget | None = None, callback: Callable | None = None)

Source code in prettyqt\widgets\pushbutton.py
def __init__(
    self,
    label: str | None = None,
    parent: QtWidgets.QWidget | None = None,
    callback: Callable | None = None,
):
    if label is None:
        label = ""
    super().__init__(label, parent)
    if callback:
        self.clicked.connect(callback)
    self.toggled.connect(self.value_changed)

RadioButton

Bases: widgets.AbstractButtonMixin, QtWidgets.QRadioButton

Source code in prettyqt\widgets\radiobutton.py
class RadioButton(widgets.AbstractButtonMixin, QtWidgets.QRadioButton):
    value_changed = core.Signal(bool)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.toggled.connect(self.value_changed)

value_changed = core.Signal(bool) class-attribute

__init__(*args, **kwargs)

Source code in prettyqt\widgets\radiobutton.py
def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.toggled.connect(self.value_changed)

RubberBand

Bases: RubberBandMixin, QtWidgets.QRubberBand

Source code in prettyqt\widgets\rubberband.py
class RubberBand(RubberBandMixin, QtWidgets.QRubberBand):
    pass

ScrollArea

Bases: widgets.AbstractScrollAreaMixin, QtWidgets.QScrollArea

Source code in prettyqt\widgets\scrollarea.py
7
8
9
class ScrollArea(widgets.AbstractScrollAreaMixin, QtWidgets.QScrollArea):
    def set_widget(self, widget: QtWidgets.QWidget):
        self.setWidget(widget)

set_widget(widget: QtWidgets.QWidget)

Source code in prettyqt\widgets\scrollarea.py
def set_widget(self, widget: QtWidgets.QWidget):
    self.setWidget(widget)

ScrollBar

Bases: ScrollBarMixin, QtWidgets.QScrollBar

Source code in prettyqt\widgets\scrollbar.py
class ScrollBar(ScrollBarMixin, QtWidgets.QScrollBar):
    pass

Scroller

Bases: core.ObjectMixin

Source code in prettyqt\widgets\scroller.py
class Scroller(core.ObjectMixin):
    def __init__(self, item: QtWidgets.QScroller):
        self.item = item

    def __getattr__(self, val):
        return getattr(self.item, val)

    def get_state(self) -> StateStr:
        """Return current state.

        Returns:
            state
        """
        return STATE.inverse[self.state()]

    def get_velocity(self) -> core.PointF:
        return core.PointF(self.velocity())

    def get_pixel_per_meter(self) -> core.PointF:
        return core.PointF(self.pixelPerMeter())

    def get_final_position(self) -> core.PointF:
        return core.PointF(self.finalPosition())

    def handle_input(
        self, input_type: InputStr, position: datatypes.PointFType, timestamp: int = 0
    ) -> bool:
        if isinstance(position, tuple):
            position = core.PointF(*position)
        if input_type not in INPUT:
            raise InvalidParamError(input_type, INPUT)
        return self.handleInput(INPUT[input_type], position, timestamp)

    def get_scroller_properties(self) -> widgets.ScrollerProperties:
        return widgets.ScrollerProperties(self.scrollerProperties())

    @classmethod
    def get_scroller(cls, obj: QtCore.QObject):
        return cls(QtWidgets.QScroller.scroller(obj))

    @staticmethod
    def grab_gesture(
        target: QtCore.QObject, gesture_type: ScrollGestureTypeStr = "touch"
    ) -> constants.GestureTypeStr:
        if gesture_type not in SCROLLER_GESTURE_TYPE:
            raise InvalidParamError(gesture_type, SCROLLER_GESTURE_TYPE)
        gesture = QtWidgets.QScroller.grabGesture(
            target, SCROLLER_GESTURE_TYPE[gesture_type]
        )
        if gesture >= 256:
            gesture -= 256
        return constants.GESTURE_TYPE.inverse[gesture]

    @staticmethod
    def grabbed_gesture(target: QtCore.QObject) -> constants.GestureTypeStr:
        return constants.GESTURE_TYPE.inverse[QtWidgets.QScroller.grabbedGesture(target)]

item = item instance-attribute

__getattr__(val)

Source code in prettyqt\widgets\scroller.py
def __getattr__(self, val):
    return getattr(self.item, val)

__init__(item: QtWidgets.QScroller)

Source code in prettyqt\widgets\scroller.py
def __init__(self, item: QtWidgets.QScroller):
    self.item = item

get_final_position() -> core.PointF

Source code in prettyqt\widgets\scroller.py
def get_final_position(self) -> core.PointF:
    return core.PointF(self.finalPosition())

get_pixel_per_meter() -> core.PointF

Source code in prettyqt\widgets\scroller.py
def get_pixel_per_meter(self) -> core.PointF:
    return core.PointF(self.pixelPerMeter())

get_scroller(obj: QtCore.QObject) classmethod

Source code in prettyqt\widgets\scroller.py
@classmethod
def get_scroller(cls, obj: QtCore.QObject):
    return cls(QtWidgets.QScroller.scroller(obj))

get_scroller_properties() -> widgets.ScrollerProperties

Source code in prettyqt\widgets\scroller.py
def get_scroller_properties(self) -> widgets.ScrollerProperties:
    return widgets.ScrollerProperties(self.scrollerProperties())

get_state() -> StateStr

Return current state.

Returns:

Type Description
StateStr

state

Source code in prettyqt\widgets\scroller.py
def get_state(self) -> StateStr:
    """Return current state.

    Returns:
        state
    """
    return STATE.inverse[self.state()]

get_velocity() -> core.PointF

Source code in prettyqt\widgets\scroller.py
def get_velocity(self) -> core.PointF:
    return core.PointF(self.velocity())

grab_gesture(target: QtCore.QObject, gesture_type: ScrollGestureTypeStr = 'touch') -> constants.GestureTypeStr staticmethod

Source code in prettyqt\widgets\scroller.py
@staticmethod
def grab_gesture(
    target: QtCore.QObject, gesture_type: ScrollGestureTypeStr = "touch"
) -> constants.GestureTypeStr:
    if gesture_type not in SCROLLER_GESTURE_TYPE:
        raise InvalidParamError(gesture_type, SCROLLER_GESTURE_TYPE)
    gesture = QtWidgets.QScroller.grabGesture(
        target, SCROLLER_GESTURE_TYPE[gesture_type]
    )
    if gesture >= 256:
        gesture -= 256
    return constants.GESTURE_TYPE.inverse[gesture]

grabbed_gesture(target: QtCore.QObject) -> constants.GestureTypeStr staticmethod

Source code in prettyqt\widgets\scroller.py
@staticmethod
def grabbed_gesture(target: QtCore.QObject) -> constants.GestureTypeStr:
    return constants.GESTURE_TYPE.inverse[QtWidgets.QScroller.grabbedGesture(target)]

handle_input(input_type: InputStr, position: datatypes.PointFType, timestamp: int = 0) -> bool

Source code in prettyqt\widgets\scroller.py
def handle_input(
    self, input_type: InputStr, position: datatypes.PointFType, timestamp: int = 0
) -> bool:
    if isinstance(position, tuple):
        position = core.PointF(*position)
    if input_type not in INPUT:
        raise InvalidParamError(input_type, INPUT)
    return self.handleInput(INPUT[input_type], position, timestamp)

ScrollerProperties

Bases: QtWidgets.QScrollerProperties

Source code in prettyqt\widgets\scrollerproperties.py
class ScrollerProperties(QtWidgets.QScrollerProperties):
    def __getitem__(self, metric: ScrollmetricStr):
        return self.get_scroll_metric(metric)

    def __setitem__(self, metric: ScrollmetricStr, value: Any):
        self.set_scroll_metric(metric, value)

    def keys(self):
        return SCROLL_METRIC.keys()

    def __iter__(self):
        return iter(SCROLL_METRIC.keys())

    def set_scroll_metric(self, metric: ScrollmetricStr, value: Any):
        """Set scroll metric.

        Args:
            metric: Scroll metric to set
            value: Value to set

        Raises:
            InvalidParamError: metric does not exist

        """
        if metric not in SCROLL_METRIC:
            raise InvalidParamError(metric, SCROLL_METRIC)
        self.setScrollMetric(SCROLL_METRIC[metric], value)

    def get_scroll_metric(self, metric: ScrollmetricStr) -> Any:
        """Return scroll metric.

        Args:
            metric: Scroll metric to get

        Raises:
            InvalidParamError: metric does not exist

        Returns:
            state
        """
        if metric not in SCROLL_METRIC:
            raise InvalidParamError(metric, SCROLL_METRIC)
        return self.scrollMetric(SCROLL_METRIC[metric])

    def get_scroll_metrics(self) -> dict:
        return {i: self.get_scroll_metric(i) for i in SCROLL_METRIC}

__getitem__(metric: ScrollmetricStr)

Source code in prettyqt\widgets\scrollerproperties.py
def __getitem__(self, metric: ScrollmetricStr):
    return self.get_scroll_metric(metric)

__iter__()

Source code in prettyqt\widgets\scrollerproperties.py
def __iter__(self):
    return iter(SCROLL_METRIC.keys())

__setitem__(metric: ScrollmetricStr, value: Any)

Source code in prettyqt\widgets\scrollerproperties.py
def __setitem__(self, metric: ScrollmetricStr, value: Any):
    self.set_scroll_metric(metric, value)

get_scroll_metric(metric: ScrollmetricStr) -> Any

Return scroll metric.

Parameters:

Name Type Description Default
metric ScrollmetricStr

Scroll metric to get

required

Raises:

Type Description
InvalidParamError

metric does not exist

Returns:

Type Description
Any

state

Source code in prettyqt\widgets\scrollerproperties.py
def get_scroll_metric(self, metric: ScrollmetricStr) -> Any:
    """Return scroll metric.

    Args:
        metric: Scroll metric to get

    Raises:
        InvalidParamError: metric does not exist

    Returns:
        state
    """
    if metric not in SCROLL_METRIC:
        raise InvalidParamError(metric, SCROLL_METRIC)
    return self.scrollMetric(SCROLL_METRIC[metric])

get_scroll_metrics() -> dict

Source code in prettyqt\widgets\scrollerproperties.py
def get_scroll_metrics(self) -> dict:
    return {i: self.get_scroll_metric(i) for i in SCROLL_METRIC}

keys()

Source code in prettyqt\widgets\scrollerproperties.py
def keys(self):
    return SCROLL_METRIC.keys()

set_scroll_metric(metric: ScrollmetricStr, value: Any)

Set scroll metric.

Parameters:

Name Type Description Default
metric ScrollmetricStr

Scroll metric to set

required
value Any

Value to set

required

Raises:

Type Description
InvalidParamError

metric does not exist

Source code in prettyqt\widgets\scrollerproperties.py
def set_scroll_metric(self, metric: ScrollmetricStr, value: Any):
    """Set scroll metric.

    Args:
        metric: Scroll metric to set
        value: Value to set

    Raises:
        InvalidParamError: metric does not exist

    """
    if metric not in SCROLL_METRIC:
        raise InvalidParamError(metric, SCROLL_METRIC)
    self.setScrollMetric(SCROLL_METRIC[metric], value)

Shortcut

Bases: core.ObjectMixin, QtWidgets.QShortcut

Source code in prettyqt\widgets\shortcut.py
class Shortcut(core.ObjectMixin, QtWidgets.QShortcut):
    def __str__(self):
        return self.key().toString()

    def serialize_field(self):
        return dict(
            auto_repeat=self.autoRepeat(),
            context=self.get_context(),
            enabled=self.isEnabled(),
            key=self.get_key(),
            whats_this=self.whatsThis(),
        )

    def set_context(self, context: constants.ContextStr):
        """Set shortcut context.

        Args:
            context: shortcut context

        Raises:
            InvalidParamError: shortcut context does not exist
        """
        if context not in constants.CONTEXT:
            raise InvalidParamError(context, constants.CONTEXT)
        self.setContext(constants.CONTEXT[context])

    def get_context(self) -> constants.ContextStr:
        """Return shortcut context.

        Returns:
            shortcut context
        """
        return constants.CONTEXT.inverse[self.context()]

    def get_key(self) -> gui.KeySequence:
        """Return the shortcut's key sequence.

        Returns:
            Key sequence
        """
        return gui.KeySequence(
            self.key().toString(), gui.KeySequence.SequenceFormat.PortableText
        )

__str__()

Source code in prettyqt\widgets\shortcut.py
def __str__(self):
    return self.key().toString()

get_context() -> constants.ContextStr

Return shortcut context.

Returns:

Type Description
constants.ContextStr

shortcut context

Source code in prettyqt\widgets\shortcut.py
def get_context(self) -> constants.ContextStr:
    """Return shortcut context.

    Returns:
        shortcut context
    """
    return constants.CONTEXT.inverse[self.context()]

get_key() -> gui.KeySequence

Return the shortcut's key sequence.

Returns:

Type Description
gui.KeySequence

Key sequence

Source code in prettyqt\widgets\shortcut.py
def get_key(self) -> gui.KeySequence:
    """Return the shortcut's key sequence.

    Returns:
        Key sequence
    """
    return gui.KeySequence(
        self.key().toString(), gui.KeySequence.SequenceFormat.PortableText
    )

serialize_field()

Source code in prettyqt\widgets\shortcut.py
def serialize_field(self):
    return dict(
        auto_repeat=self.autoRepeat(),
        context=self.get_context(),
        enabled=self.isEnabled(),
        key=self.get_key(),
        whats_this=self.whatsThis(),
    )

set_context(context: constants.ContextStr)

Set shortcut context.

Parameters:

Name Type Description Default
context constants.ContextStr

shortcut context

required

Raises:

Type Description
InvalidParamError

shortcut context does not exist

Source code in prettyqt\widgets\shortcut.py
def set_context(self, context: constants.ContextStr):
    """Set shortcut context.

    Args:
        context: shortcut context

    Raises:
        InvalidParamError: shortcut context does not exist
    """
    if context not in constants.CONTEXT:
        raise InvalidParamError(context, constants.CONTEXT)
    self.setContext(constants.CONTEXT[context])

SizeGrip

Bases: widgets.WidgetMixin, QtWidgets.QSizeGrip

Source code in prettyqt\widgets\sizegrip.py
class SizeGrip(widgets.WidgetMixin, QtWidgets.QSizeGrip):
    pass

SizePolicy

Bases: prettyprinter.PrettyPrinter, QtWidgets.QSizePolicy

Source code in prettyqt\widgets\sizepolicy.py
class SizePolicy(prettyprinter.PrettyPrinter, QtWidgets.QSizePolicy):
    def __repr__(self) -> str:
        cls_name = type(self).__name__
        params = helpers.format_kwargs(self.__getstate__())
        return f"{cls_name}({params})"

    def __getstate__(self):
        return dict(
            has_height_for_width=self.hasHeightForWidth(),
            has_width_for_height=self.hasWidthForHeight(),
            horizontal_stretch=self.horizontalStretch(),
            vertical_stretch=self.verticalStretch(),
            horizontal_policy=self.get_horizontal_policy(),
            vertical_policy=self.get_vertical_policy(),
            retain_size_when_hidden=self.retainSizeWhenHidden(),
            control_type=self.get_control_type(),
        )

    def __setstate__(self, state: dict[str, Any]) -> None:
        self.setHeightForWidth(state["has_height_for_width"])
        self.setWidthForHeight(state["has_width_for_height"])
        self.setHorizontalStretch(state["horizontal_stretch"])
        self.setVerticalStretch(state["vertical_stretch"])
        self.set_horizontal_policy(state["horizontal_policy"])
        self.set_vertical_policy(state["vertical_policy"])
        self.setRetainSizeWhenHidden(state["retain_size_when_hidden"])
        self.set_control_type(state["control_type"])

    def __reduce__(self):
        return type(self), (), self.__getstate__()

    def serialize(self) -> dict[str, Any]:
        return self.__getstate__()

    @classmethod
    def clone(cls, qpol: QtWidgets.QSizePolicy) -> SizePolicy:
        pol = cls(qpol.horizontalPolicy(), qpol.verticalPolicy(), qpol.controlType())
        pol.setHeightForWidth(qpol.hasHeightForWidth())
        pol.setWidthForHeight(qpol.hasWidthForHeight())
        pol.setHorizontalStretch(qpol.horizontalStretch())
        pol.setVerticalStretch(qpol.verticalStretch())
        pol.setRetainSizeWhenHidden(qpol.retainSizeWhenHidden())
        return pol

    def get_horizontal_policy(self) -> SizePolicyStr:
        """Return size policy.

        Returns:
            horizontal size policy
        """
        return SIZE_POLICY.inverse[self.horizontalPolicy()]

    def set_horizontal_policy(self, policy: SizePolicyStr) -> None:
        """Set the horizontal policy.

        Args:
            policy: policy to set

        Raises:
            InvalidParamError: policy does not exist
        """
        self.setHorizontalPolicy(SIZE_POLICY[policy])

    def get_vertical_policy(self) -> SizePolicyStr:
        """Return size policy.

        Returns:
            vertical size policy

        """
        return SIZE_POLICY.inverse[self.verticalPolicy()]

    def set_vertical_policy(self, policy: SizePolicyStr) -> None:
        """Set the horizontal policy.

        Args:
            policy: policy to set

        Raises:
            InvalidParamError: policy does not exist
        """
        self.setVerticalPolicy(SIZE_POLICY[policy])

    def get_control_type(self) -> ControlTypeStr:
        """Return control type.

        Returns:
            control type
        """
        return CONTROL_TYPE.inverse[self.controlType()]

    def set_control_type(self, typ: ControlTypeStr) -> None:
        """Set the control type.

        Args:
            typ: control type to set

        Raises:
            InvalidParamError: control type does not exist
        """
        if typ not in CONTROL_TYPE:
            raise InvalidParamError(typ, CONTROL_TYPE)
        self.setControlType(CONTROL_TYPE[typ])

__getstate__()

Source code in prettyqt\widgets\sizepolicy.py
def __getstate__(self):
    return dict(
        has_height_for_width=self.hasHeightForWidth(),
        has_width_for_height=self.hasWidthForHeight(),
        horizontal_stretch=self.horizontalStretch(),
        vertical_stretch=self.verticalStretch(),
        horizontal_policy=self.get_horizontal_policy(),
        vertical_policy=self.get_vertical_policy(),
        retain_size_when_hidden=self.retainSizeWhenHidden(),
        control_type=self.get_control_type(),
    )

__reduce__()

Source code in prettyqt\widgets\sizepolicy.py
def __reduce__(self):
    return type(self), (), self.__getstate__()

__repr__() -> str

Source code in prettyqt\widgets\sizepolicy.py
def __repr__(self) -> str:
    cls_name = type(self).__name__
    params = helpers.format_kwargs(self.__getstate__())
    return f"{cls_name}({params})"

__setstate__(state: dict[str, Any]) -> None

Source code in prettyqt\widgets\sizepolicy.py
def __setstate__(self, state: dict[str, Any]) -> None:
    self.setHeightForWidth(state["has_height_for_width"])
    self.setWidthForHeight(state["has_width_for_height"])
    self.setHorizontalStretch(state["horizontal_stretch"])
    self.setVerticalStretch(state["vertical_stretch"])
    self.set_horizontal_policy(state["horizontal_policy"])
    self.set_vertical_policy(state["vertical_policy"])
    self.setRetainSizeWhenHidden(state["retain_size_when_hidden"])
    self.set_control_type(state["control_type"])

clone(qpol: QtWidgets.QSizePolicy) -> SizePolicy classmethod

Source code in prettyqt\widgets\sizepolicy.py
@classmethod
def clone(cls, qpol: QtWidgets.QSizePolicy) -> SizePolicy:
    pol = cls(qpol.horizontalPolicy(), qpol.verticalPolicy(), qpol.controlType())
    pol.setHeightForWidth(qpol.hasHeightForWidth())
    pol.setWidthForHeight(qpol.hasWidthForHeight())
    pol.setHorizontalStretch(qpol.horizontalStretch())
    pol.setVerticalStretch(qpol.verticalStretch())
    pol.setRetainSizeWhenHidden(qpol.retainSizeWhenHidden())
    return pol

get_control_type() -> ControlTypeStr

Return control type.

Returns:

Type Description
ControlTypeStr

control type

Source code in prettyqt\widgets\sizepolicy.py
def get_control_type(self) -> ControlTypeStr:
    """Return control type.

    Returns:
        control type
    """
    return CONTROL_TYPE.inverse[self.controlType()]

get_horizontal_policy() -> SizePolicyStr

Return size policy.

Returns:

Type Description
SizePolicyStr

horizontal size policy

Source code in prettyqt\widgets\sizepolicy.py
def get_horizontal_policy(self) -> SizePolicyStr:
    """Return size policy.

    Returns:
        horizontal size policy
    """
    return SIZE_POLICY.inverse[self.horizontalPolicy()]

get_vertical_policy() -> SizePolicyStr

Return size policy.

Returns:

Type Description
SizePolicyStr

vertical size policy

Source code in prettyqt\widgets\sizepolicy.py
def get_vertical_policy(self) -> SizePolicyStr:
    """Return size policy.

    Returns:
        vertical size policy

    """
    return SIZE_POLICY.inverse[self.verticalPolicy()]

serialize() -> dict[str, Any]

Source code in prettyqt\widgets\sizepolicy.py
def serialize(self) -> dict[str, Any]:
    return self.__getstate__()

set_control_type(typ: ControlTypeStr) -> None

Set the control type.

Parameters:

Name Type Description Default
typ ControlTypeStr

control type to set

required

Raises:

Type Description
InvalidParamError

control type does not exist

Source code in prettyqt\widgets\sizepolicy.py
def set_control_type(self, typ: ControlTypeStr) -> None:
    """Set the control type.

    Args:
        typ: control type to set

    Raises:
        InvalidParamError: control type does not exist
    """
    if typ not in CONTROL_TYPE:
        raise InvalidParamError(typ, CONTROL_TYPE)
    self.setControlType(CONTROL_TYPE[typ])

set_horizontal_policy(policy: SizePolicyStr) -> None

Set the horizontal policy.

Parameters:

Name Type Description Default
policy SizePolicyStr

policy to set

required

Raises:

Type Description
InvalidParamError

policy does not exist

Source code in prettyqt\widgets\sizepolicy.py
def set_horizontal_policy(self, policy: SizePolicyStr) -> None:
    """Set the horizontal policy.

    Args:
        policy: policy to set

    Raises:
        InvalidParamError: policy does not exist
    """
    self.setHorizontalPolicy(SIZE_POLICY[policy])

set_vertical_policy(policy: SizePolicyStr) -> None

Set the horizontal policy.

Parameters:

Name Type Description Default
policy SizePolicyStr

policy to set

required

Raises:

Type Description
InvalidParamError

policy does not exist

Source code in prettyqt\widgets\sizepolicy.py
def set_vertical_policy(self, policy: SizePolicyStr) -> None:
    """Set the horizontal policy.

    Args:
        policy: policy to set

    Raises:
        InvalidParamError: policy does not exist
    """
    self.setVerticalPolicy(SIZE_POLICY[policy])

Slider

Bases: widgets.AbstractSliderMixin, QtWidgets.QSlider

Source code in prettyqt\widgets\slider.py
class Slider(widgets.AbstractSliderMixin, QtWidgets.QSlider):
    value_changed = core.Signal(int)

    def __init__(
        self,
        orientation: (constants.OrientationStr | QtCore.Qt.Orientation) = "horizontal",
        parent: QtWidgets.QWidget | None = None,
    ):
        if isinstance(orientation, QtCore.Qt.Orientation):
            ori = orientation
        else:
            ori = constants.ORIENTATION[orientation]
        super().__init__(ori, parent)
        self.valueChanged.connect(self.on_value_change)

    def set_tick_position(self, position: TickPositionAllStr):
        """Set the tick position for the slider.

        For vertical orientation, "above" equals to "left" and "below" to "right".

        Args:
            position: position for the ticks
        """
        if position == "left":
            position = "above"
        elif position == "right":
            position = "below"
        elif position not in TICK_POSITION:
            raise InvalidParamError(position, TICK_POSITION)
        self.setTickPosition(TICK_POSITION[position])

    def get_tick_position(self) -> TickPositionStr:
        """Return tick position.

        Returns:
            tick position
        """
        return TICK_POSITION.inverse[self.tickPosition()]

value_changed = core.Signal(int) class-attribute

__init__(orientation: constants.OrientationStr | QtCore.Qt.Orientation = 'horizontal', parent: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\slider.py
def __init__(
    self,
    orientation: (constants.OrientationStr | QtCore.Qt.Orientation) = "horizontal",
    parent: QtWidgets.QWidget | None = None,
):
    if isinstance(orientation, QtCore.Qt.Orientation):
        ori = orientation
    else:
        ori = constants.ORIENTATION[orientation]
    super().__init__(ori, parent)
    self.valueChanged.connect(self.on_value_change)

get_tick_position() -> TickPositionStr

Return tick position.

Returns:

Type Description
TickPositionStr

tick position

Source code in prettyqt\widgets\slider.py
def get_tick_position(self) -> TickPositionStr:
    """Return tick position.

    Returns:
        tick position
    """
    return TICK_POSITION.inverse[self.tickPosition()]

set_tick_position(position: TickPositionAllStr)

Set the tick position for the slider.

For vertical orientation, "above" equals to "left" and "below" to "right".

Parameters:

Name Type Description Default
position TickPositionAllStr

position for the ticks

required
Source code in prettyqt\widgets\slider.py
def set_tick_position(self, position: TickPositionAllStr):
    """Set the tick position for the slider.

    For vertical orientation, "above" equals to "left" and "below" to "right".

    Args:
        position: position for the ticks
    """
    if position == "left":
        position = "above"
    elif position == "right":
        position = "below"
    elif position not in TICK_POSITION:
        raise InvalidParamError(position, TICK_POSITION)
    self.setTickPosition(TICK_POSITION[position])

SpacerItem

Bases: widgets.LayoutItemMixin, QtWidgets.QSpacerItem

Source code in prettyqt\widgets\spaceritem.py
class SpacerItem(widgets.LayoutItemMixin, QtWidgets.QSpacerItem):
    def __init__(
        self,
        w: int,
        h: int,
        h_policy: QtWidgets.QSizePolicy.Policy
        | widgets.sizepolicy.SizePolicyStr = "minimum",
        v_policy: QtWidgets.QSizePolicy.Policy
        | widgets.sizepolicy.SizePolicyStr = "minimum",
    ):
        if isinstance(h_policy, QtWidgets.QSizePolicy.Policy):
            h_pol = h_policy
        else:
            h_pol = widgets.sizepolicy.SIZE_POLICY[h_policy]
        if isinstance(v_policy, QtWidgets.QSizePolicy.Policy):
            v_pol = v_policy
        else:
            v_pol = widgets.sizepolicy.SIZE_POLICY[v_policy]
        super().__init__(w, h, h_pol, v_pol)

    def change_size(
        self,
        w: int,
        h: int,
        h_policy: widgets.sizepolicy.SizePolicyStr = "minimum",
        v_policy: widgets.sizepolicy.SizePolicyStr = "minimum",
    ):
        h_pol = widgets.sizepolicy.SIZE_POLICY[h_policy]
        v_pol = widgets.sizepolicy.SIZE_POLICY[v_policy]
        self.changeSize(w, h, h_pol, v_pol)

    def get_size_policy(self) -> widgets.SizePolicy:
        return widgets.SizePolicy.clone(self.sizePolicy())

__init__(w: int, h: int, h_policy: QtWidgets.QSizePolicy.Policy | widgets.sizepolicy.SizePolicyStr = 'minimum', v_policy: QtWidgets.QSizePolicy.Policy | widgets.sizepolicy.SizePolicyStr = 'minimum')

Source code in prettyqt\widgets\spaceritem.py
def __init__(
    self,
    w: int,
    h: int,
    h_policy: QtWidgets.QSizePolicy.Policy
    | widgets.sizepolicy.SizePolicyStr = "minimum",
    v_policy: QtWidgets.QSizePolicy.Policy
    | widgets.sizepolicy.SizePolicyStr = "minimum",
):
    if isinstance(h_policy, QtWidgets.QSizePolicy.Policy):
        h_pol = h_policy
    else:
        h_pol = widgets.sizepolicy.SIZE_POLICY[h_policy]
    if isinstance(v_policy, QtWidgets.QSizePolicy.Policy):
        v_pol = v_policy
    else:
        v_pol = widgets.sizepolicy.SIZE_POLICY[v_policy]
    super().__init__(w, h, h_pol, v_pol)

change_size(w: int, h: int, h_policy: widgets.sizepolicy.SizePolicyStr = 'minimum', v_policy: widgets.sizepolicy.SizePolicyStr = 'minimum')

Source code in prettyqt\widgets\spaceritem.py
def change_size(
    self,
    w: int,
    h: int,
    h_policy: widgets.sizepolicy.SizePolicyStr = "minimum",
    v_policy: widgets.sizepolicy.SizePolicyStr = "minimum",
):
    h_pol = widgets.sizepolicy.SIZE_POLICY[h_policy]
    v_pol = widgets.sizepolicy.SIZE_POLICY[v_policy]
    self.changeSize(w, h, h_pol, v_pol)

get_size_policy() -> widgets.SizePolicy

Source code in prettyqt\widgets\spaceritem.py
def get_size_policy(self) -> widgets.SizePolicy:
    return widgets.SizePolicy.clone(self.sizePolicy())

SpinBox

Bases: widgets.AbstractSpinBoxMixin, QtWidgets.QSpinBox

Source code in prettyqt\widgets\spinbox.py
class SpinBox(widgets.AbstractSpinBoxMixin, QtWidgets.QSpinBox):
    value_changed = core.Signal(int)

    def __init__(
        self,
        parent: QtWidgets.QWidget | None = None,
        min_value: int | None = None,
        max_value: int | None = None,
        default_value: int | None = None,
    ):
        super().__init__(parent)
        self.valueChanged.connect(self.value_changed)
        self.set_range(min_value, max_value)
        if default_value is not None:
            self.set_value(default_value)

    def set_range(self, start: int | None, end: int | None):
        if start is None:
            start = -2147483647
        if end is None:
            end = 2147483647
        self.setRange(start, end)

    def set_step_size(self, step_size):
        self.setSingleStep(step_size)

value_changed = core.Signal(int) class-attribute

__init__(parent: QtWidgets.QWidget | None = None, min_value: int | None = None, max_value: int | None = None, default_value: int | None = None)

Source code in prettyqt\widgets\spinbox.py
def __init__(
    self,
    parent: QtWidgets.QWidget | None = None,
    min_value: int | None = None,
    max_value: int | None = None,
    default_value: int | None = None,
):
    super().__init__(parent)
    self.valueChanged.connect(self.value_changed)
    self.set_range(min_value, max_value)
    if default_value is not None:
        self.set_value(default_value)

set_range(start: int | None, end: int | None)

Source code in prettyqt\widgets\spinbox.py
def set_range(self, start: int | None, end: int | None):
    if start is None:
        start = -2147483647
    if end is None:
        end = 2147483647
    self.setRange(start, end)

set_step_size(step_size)

Source code in prettyqt\widgets\spinbox.py
def set_step_size(self, step_size):
    self.setSingleStep(step_size)

SplashScreen

Bases: SplashScreenMixin, QtWidgets.QSplashScreen

Source code in prettyqt\widgets\splashscreen.py
class SplashScreen(SplashScreenMixin, QtWidgets.QSplashScreen):
    pass

Splitter

Bases: SplitterMixin, QtWidgets.QSplitter

Source code in prettyqt\widgets\splitter.py
class Splitter(SplitterMixin, QtWidgets.QSplitter):
    pass

SplitterHandle

Bases: widgets.WidgetMixin, QtWidgets.QSplitterHandle

Source code in prettyqt\widgets\splitterhandle.py
class SplitterHandle(widgets.WidgetMixin, QtWidgets.QSplitterHandle):
    def __init__(
        self,
        orientation: constants.OrientationStr | QtCore.Qt.Orientation,
        parent: QtWidgets.QSplitter,
    ):
        if isinstance(orientation, QtCore.Qt.Orientation):
            ori = orientation
        else:
            ori = constants.ORIENTATION[orientation]
        super().__init__(ori, parent)

    def set_orientation(self, orientation: constants.OrientationStr):
        """Set the orientation of the slider.

        Args:
            orientation: orientation for the slider

        Raises:
            InvalidParamError: orientation does not exist
        """
        if orientation not in constants.ORIENTATION:
            raise InvalidParamError(orientation, constants.ORIENTATION)
        self.setOrientation(constants.ORIENTATION[orientation])

    def get_orientation(self) -> constants.OrientationStr:
        """Return current orientation.

        Returns:
            orientation
        """
        return constants.ORIENTATION.inverse[self.orientation()]

__init__(orientation: constants.OrientationStr | QtCore.Qt.Orientation, parent: QtWidgets.QSplitter)

Source code in prettyqt\widgets\splitterhandle.py
def __init__(
    self,
    orientation: constants.OrientationStr | QtCore.Qt.Orientation,
    parent: QtWidgets.QSplitter,
):
    if isinstance(orientation, QtCore.Qt.Orientation):
        ori = orientation
    else:
        ori = constants.ORIENTATION[orientation]
    super().__init__(ori, parent)

get_orientation() -> constants.OrientationStr

Return current orientation.

Returns:

Type Description
constants.OrientationStr

orientation

Source code in prettyqt\widgets\splitterhandle.py
def get_orientation(self) -> constants.OrientationStr:
    """Return current orientation.

    Returns:
        orientation
    """
    return constants.ORIENTATION.inverse[self.orientation()]

set_orientation(orientation: constants.OrientationStr)

Set the orientation of the slider.

Parameters:

Name Type Description Default
orientation constants.OrientationStr

orientation for the slider

required

Raises:

Type Description
InvalidParamError

orientation does not exist

Source code in prettyqt\widgets\splitterhandle.py
def set_orientation(self, orientation: constants.OrientationStr):
    """Set the orientation of the slider.

    Args:
        orientation: orientation for the slider

    Raises:
        InvalidParamError: orientation does not exist
    """
    if orientation not in constants.ORIENTATION:
        raise InvalidParamError(orientation, constants.ORIENTATION)
    self.setOrientation(constants.ORIENTATION[orientation])

StackedLayout

Bases: widgets.LayoutMixin, QtWidgets.QStackedLayout

Source code in prettyqt\widgets\stackedlayout.py
class StackedLayout(widgets.LayoutMixin, QtWidgets.QStackedLayout):
    # def serialize_fields(self):
    #     return dict(items=self.get_children())

    # def __setstate__(self, state):
    #     for item in state["items"]:
    #         self.add(item)

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    def __add__(self, other: QtWidgets.QWidget | QtWidgets.QLayout):
        self.add(other)
        return self

    def set_current_widget(self, widget: QtWidgets.QWidget):
        self.setCurrentWidget(widget)

__add__(other: QtWidgets.QWidget | QtWidgets.QLayout)

Source code in prettyqt\widgets\stackedlayout.py
def __add__(self, other: QtWidgets.QWidget | QtWidgets.QLayout):
    self.add(other)
    return self

set_current_widget(widget: QtWidgets.QWidget)

Source code in prettyqt\widgets\stackedlayout.py
def set_current_widget(self, widget: QtWidgets.QWidget):
    self.setCurrentWidget(widget)

StackedWidget

Bases: widgets.FrameMixin, QtWidgets.QStackedWidget

Source code in prettyqt\widgets\stackedwidget.py
class StackedWidget(widgets.FrameMixin, QtWidgets.QStackedWidget):
    # def __setstate__(self, state):
    #     for item in state["items"]:
    #         self.add(item)

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    def __add__(self, other: QtWidgets.QWidget) -> StackedWidget:
        self.addWidget(other)
        return self

    def __getitem__(self, index: int) -> QtWidgets.QWidget:
        return self.widget(index)

    def __iter__(self) -> Iterator[QtWidgets.QWidget]:
        return iter(self.widget(i) for i in range(self.count()))

    def __len__(self):
        # needed for PySide2
        return self.count()

    def __contains__(self, item: QtWidgets.QWidget):
        return self.indexOf(item) >= 0

    def serialize_fields(self):
        return dict(items=list(self))

    def set_current_widget(self, widget: QtWidgets.QWidget):
        self.setCurrentWidget(widget)

__add__(other: QtWidgets.QWidget) -> StackedWidget

Source code in prettyqt\widgets\stackedwidget.py
def __add__(self, other: QtWidgets.QWidget) -> StackedWidget:
    self.addWidget(other)
    return self

__contains__(item: QtWidgets.QWidget)

Source code in prettyqt\widgets\stackedwidget.py
def __contains__(self, item: QtWidgets.QWidget):
    return self.indexOf(item) >= 0

__getitem__(index: int) -> QtWidgets.QWidget

Source code in prettyqt\widgets\stackedwidget.py
def __getitem__(self, index: int) -> QtWidgets.QWidget:
    return self.widget(index)

__iter__() -> Iterator[QtWidgets.QWidget]

Source code in prettyqt\widgets\stackedwidget.py
def __iter__(self) -> Iterator[QtWidgets.QWidget]:
    return iter(self.widget(i) for i in range(self.count()))

__len__()

Source code in prettyqt\widgets\stackedwidget.py
def __len__(self):
    # needed for PySide2
    return self.count()

serialize_fields()

Source code in prettyqt\widgets\stackedwidget.py
def serialize_fields(self):
    return dict(items=list(self))

set_current_widget(widget: QtWidgets.QWidget)

Source code in prettyqt\widgets\stackedwidget.py
def set_current_widget(self, widget: QtWidgets.QWidget):
    self.setCurrentWidget(widget)

StatusBar

Bases: widgets.WidgetMixin, QtWidgets.QStatusBar

Source code in prettyqt\widgets\statusbar.py
class StatusBar(widgets.WidgetMixin, QtWidgets.QStatusBar):
    def __init__(self, *args, **kwargs) -> None:
        super().__init__(*args, **kwargs)
        self.progress_bar = widgets.ProgressBar()

    def __add__(self, other: QtWidgets.QAction | QtWidgets.QWidget) -> StatusBar:
        match other:
            case QtWidgets.QAction():
                self.addAction(other)
                return self
            case QtWidgets.QWidget():
                self.addWidget(other)
                return self
            case _:
                raise TypeError(other)

    def setup_default_bar(self) -> None:
        # This is simply to show the bar
        self.progress_bar.hide()
        self.progress_bar.setRange(0, 0)
        self.progress_bar.setFixedSize(200, 20)
        self.progress_bar.setTextVisible(False)
        self.addPermanentWidget(self.progress_bar)

    def add_action(self, action: QtWidgets.QAction) -> None:
        self.addAction(action)

    def add_widget(self, widget: QtWidgets.QWidget, permanent: bool = False) -> None:
        if permanent:
            self.addPermanentWidget(widget)
        else:
            self.addWidget(widget)

    def show_message(self, message: str, timeout: int = 0) -> None:
        self.showMessage(message, timeout)

progress_bar = widgets.ProgressBar() instance-attribute

__add__(other: QtWidgets.QAction | QtWidgets.QWidget) -> StatusBar

Source code in prettyqt\widgets\statusbar.py
def __add__(self, other: QtWidgets.QAction | QtWidgets.QWidget) -> StatusBar:
    match other:
        case QtWidgets.QAction():
            self.addAction(other)
            return self
        case QtWidgets.QWidget():
            self.addWidget(other)
            return self
        case _:
            raise TypeError(other)

__init__(*args, **kwargs) -> None

Source code in prettyqt\widgets\statusbar.py
def __init__(self, *args, **kwargs) -> None:
    super().__init__(*args, **kwargs)
    self.progress_bar = widgets.ProgressBar()

add_action(action: QtWidgets.QAction) -> None

Source code in prettyqt\widgets\statusbar.py
def add_action(self, action: QtWidgets.QAction) -> None:
    self.addAction(action)

add_widget(widget: QtWidgets.QWidget, permanent: bool = False) -> None

Source code in prettyqt\widgets\statusbar.py
def add_widget(self, widget: QtWidgets.QWidget, permanent: bool = False) -> None:
    if permanent:
        self.addPermanentWidget(widget)
    else:
        self.addWidget(widget)

setup_default_bar() -> None

Source code in prettyqt\widgets\statusbar.py
def setup_default_bar(self) -> None:
    # This is simply to show the bar
    self.progress_bar.hide()
    self.progress_bar.setRange(0, 0)
    self.progress_bar.setFixedSize(200, 20)
    self.progress_bar.setTextVisible(False)
    self.addPermanentWidget(self.progress_bar)

show_message(message: str, timeout: int = 0) -> None

Source code in prettyqt\widgets\statusbar.py
def show_message(self, message: str, timeout: int = 0) -> None:
    self.showMessage(message, timeout)

Style

Bases: StyleMixin, QtWidgets.QStyle

Source code in prettyqt\widgets\style.py
class Style(StyleMixin, QtWidgets.QStyle):
    pass

StyleFactory

Bases: QtWidgets.QStyleFactory

Source code in prettyqt\widgets\stylefactory.py
class StyleFactory(QtWidgets.QStyleFactory):
    pass

StyleMixin

Bases: core.ObjectMixin

Source code in prettyqt\widgets\style.py
class StyleMixin(core.ObjectMixin):
    def draw_primitive(
        self,
        element: SimpleControlStr,
        option: QtWidgets.QStyleOption,
        painter: QtGui.QPainter,
        widget: QtWidgets.QWidget | None = None,
    ):
        if element not in PRIMITIVE_ELEMENT:
            raise InvalidParamError(element, PRIMITIVE_ELEMENT)
        self.drawPrimitive(PRIMITIVE_ELEMENT[element], option, painter, widget)

    def draw_control(
        self,
        control: ControlElementStr,
        option: QtWidgets.QStyleOption,
        painter: QtGui.QPainter,
        widget: QtWidgets.QWidget | None = None,
    ):
        if control not in CONTROL_ELEMENT:
            raise InvalidParamError(control, CONTROL_ELEMENT)
        self.drawPrimitive(CONTROL_ELEMENT[control], option, painter, widget)

    def get_layout_spacing(
        self,
        control_1: widgets.sizepolicy.ControlTypeStr,
        control_2: widgets.sizepolicy.ControlTypeStr,
        orientation: constants.OrientationStr,
        option_or_widget: QtCore.QWidgets.QStyleOption | QtWidgets.QWidget | None = None,
    ):
        c1 = widgets.sizepolicy.CONTROL_TYPE[control_1]
        c2 = widgets.sizepolicy.CONTROL_TYPE[control_2]
        o = constants.ORIENTATION[orientation]
        match option_or_widget:
            case QtWidgets.QWidget():
                return self.layoutSpacing(c1, c2, o, None, option_or_widget)
            case QtWidgets.QStyleOption() | None:
                return self.layoutSpacing(c1, c2, o, option_or_widget)
            case _:
                raise ValueError(option_or_widget)

draw_control(control: ControlElementStr, option: QtWidgets.QStyleOption, painter: QtGui.QPainter, widget: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\style.py
def draw_control(
    self,
    control: ControlElementStr,
    option: QtWidgets.QStyleOption,
    painter: QtGui.QPainter,
    widget: QtWidgets.QWidget | None = None,
):
    if control not in CONTROL_ELEMENT:
        raise InvalidParamError(control, CONTROL_ELEMENT)
    self.drawPrimitive(CONTROL_ELEMENT[control], option, painter, widget)

draw_primitive(element: SimpleControlStr, option: QtWidgets.QStyleOption, painter: QtGui.QPainter, widget: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\style.py
def draw_primitive(
    self,
    element: SimpleControlStr,
    option: QtWidgets.QStyleOption,
    painter: QtGui.QPainter,
    widget: QtWidgets.QWidget | None = None,
):
    if element not in PRIMITIVE_ELEMENT:
        raise InvalidParamError(element, PRIMITIVE_ELEMENT)
    self.drawPrimitive(PRIMITIVE_ELEMENT[element], option, painter, widget)

get_layout_spacing(control_1: widgets.sizepolicy.ControlTypeStr, control_2: widgets.sizepolicy.ControlTypeStr, orientation: constants.OrientationStr, option_or_widget: QtCore.QWidgets.QStyleOption | QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\style.py
def get_layout_spacing(
    self,
    control_1: widgets.sizepolicy.ControlTypeStr,
    control_2: widgets.sizepolicy.ControlTypeStr,
    orientation: constants.OrientationStr,
    option_or_widget: QtCore.QWidgets.QStyleOption | QtWidgets.QWidget | None = None,
):
    c1 = widgets.sizepolicy.CONTROL_TYPE[control_1]
    c2 = widgets.sizepolicy.CONTROL_TYPE[control_2]
    o = constants.ORIENTATION[orientation]
    match option_or_widget:
        case QtWidgets.QWidget():
            return self.layoutSpacing(c1, c2, o, None, option_or_widget)
        case QtWidgets.QStyleOption() | None:
            return self.layoutSpacing(c1, c2, o, option_or_widget)
        case _:
            raise ValueError(option_or_widget)

StyleOption

Bases: StyleOptionMixin, QtWidgets.QStyleOption

Source code in prettyqt\widgets\styleoption.py
class StyleOption(StyleOptionMixin, QtWidgets.QStyleOption):
    pass

StyleOptionButton

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionButton

Source code in prettyqt\widgets\styleoptionbutton.py
class StyleOptionButton(widgets.StyleOptionMixin, QtWidgets.QStyleOptionButton):
    pass

StyleOptionComboBox

Bases: widgets.StyleOptionComplexMixin, QtWidgets.QStyleOptionComboBox

Source code in prettyqt\widgets\styleoptioncombobox.py
class StyleOptionComboBox(
    widgets.StyleOptionComplexMixin, QtWidgets.QStyleOptionComboBox
):
    pass

StyleOptionComplex

Bases: StyleOptionComplexMixin, QtWidgets.QStyleOptionComplex

Source code in prettyqt\widgets\styleoptioncomplex.py
class StyleOptionComplex(StyleOptionComplexMixin, QtWidgets.QStyleOptionComplex):
    pass

StyleOptionComplexMixin

Bases: widgets.StyleOptionMixin

Source code in prettyqt\widgets\styleoptioncomplex.py
class StyleOptionComplexMixin(widgets.StyleOptionMixin):
    pass

StyleOptionDockWidget

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionDockWidget

Source code in prettyqt\widgets\styleoptiondockwidget.py
class StyleOptionDockWidget(widgets.StyleOptionMixin, QtWidgets.QStyleOptionDockWidget):
    pass

StyleOptionFocusRect

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionFocusRect

Source code in prettyqt\widgets\styleoptionfocusrect.py
class StyleOptionFocusRect(widgets.StyleOptionMixin, QtWidgets.QStyleOptionFocusRect):
    pass

StyleOptionFrame

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionFrame

Source code in prettyqt\widgets\styleoptionframe.py
class StyleOptionFrame(widgets.StyleOptionMixin, QtWidgets.QStyleOptionFrame):
    pass

StyleOptionGraphicsItem

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionGraphicsItem

Source code in prettyqt\widgets\styleoptiongraphicsitem.py
class StyleOptionGraphicsItem(
    widgets.StyleOptionMixin, QtWidgets.QStyleOptionGraphicsItem
):
    pass

StyleOptionGroupBox

Bases: widgets.StyleOptionComplex, QtWidgets.QStyleOptionGroupBox

Source code in prettyqt\widgets\styleoptiongroupbox.py
class StyleOptionGroupBox(widgets.StyleOptionComplex, QtWidgets.QStyleOptionGroupBox):
    pass

StyleOptionHeader

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionHeader

Source code in prettyqt\widgets\styleoptionheader.py
class StyleOptionHeader(widgets.StyleOptionMixin, QtWidgets.QStyleOptionHeader):
    pass

StyleOptionMenuItem

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionMenuItem

Source code in prettyqt\widgets\styleoptionmenuitem.py
class StyleOptionMenuItem(widgets.StyleOptionMixin, QtWidgets.QStyleOptionMenuItem):
    pass

StyleOptionMixin

Source code in prettyqt\widgets\styleoption.py
class StyleOptionMixin:
    @classmethod
    def based_on(cls, widget: QtWidgets.QWidget) -> StyleOption:
        opt = cls()
        opt.initFrom(widget)
        return opt

based_on(widget: QtWidgets.QWidget) -> StyleOption classmethod

Source code in prettyqt\widgets\styleoption.py
@classmethod
def based_on(cls, widget: QtWidgets.QWidget) -> StyleOption:
    opt = cls()
    opt.initFrom(widget)
    return opt

StyleOptionProgressBar

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionProgressBar

Source code in prettyqt\widgets\styleoptionprogressbar.py
class StyleOptionProgressBar(widgets.StyleOptionMixin, QtWidgets.QStyleOptionProgressBar):
    pass

StyleOptionRubberBand

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionRubberBand

Source code in prettyqt\widgets\styleoptionrubberband.py
class StyleOptionRubberBand(widgets.StyleOptionMixin, QtWidgets.QStyleOptionRubberBand):
    pass

StyleOptionSizeGrip

Bases: widgets.StyleOptionComplexMixin, QtWidgets.QStyleOptionSizeGrip

Source code in prettyqt\widgets\styleoptionsizegrip.py
class StyleOptionSizeGrip(
    widgets.StyleOptionComplexMixin, QtWidgets.QStyleOptionSizeGrip
):
    pass

StyleOptionSlider

Bases: widgets.StyleOptionComplexMixin, QtWidgets.QStyleOptionSlider

Source code in prettyqt\widgets\styleoptionslider.py
class StyleOptionSlider(widgets.StyleOptionComplexMixin, QtWidgets.QStyleOptionSlider):
    def is_horizontal(self) -> bool:
        """Check if silder is horizontal.

        Returns:
            True if horizontal, else False
        """
        return self.orientation == constants.HORIZONTAL

    def is_vertical(self) -> bool:
        """Check if silder is vertical.

        Returns:
            True if vertical, else False
        """
        return self.orientation == constants.VERTICAL

    def set_horizontal(self) -> None:
        """Set slider orientation to horizontal."""
        self.orientation = constants.HORIZONTAL

    def set_vertical(self) -> None:
        """Set slider orientation to vertical."""
        self.orientation = constants.VERTICAL

    def get_orientation(self) -> Literal["horizontal", "vertical"]:
        return "horizontal" if self.is_horizontal() else "vertical"

get_orientation() -> Literal['horizontal', 'vertical']

Source code in prettyqt\widgets\styleoptionslider.py
def get_orientation(self) -> Literal["horizontal", "vertical"]:
    return "horizontal" if self.is_horizontal() else "vertical"

is_horizontal() -> bool

Check if silder is horizontal.

Returns:

Type Description
bool

True if horizontal, else False

Source code in prettyqt\widgets\styleoptionslider.py
def is_horizontal(self) -> bool:
    """Check if silder is horizontal.

    Returns:
        True if horizontal, else False
    """
    return self.orientation == constants.HORIZONTAL

is_vertical() -> bool

Check if silder is vertical.

Returns:

Type Description
bool

True if vertical, else False

Source code in prettyqt\widgets\styleoptionslider.py
def is_vertical(self) -> bool:
    """Check if silder is vertical.

    Returns:
        True if vertical, else False
    """
    return self.orientation == constants.VERTICAL

set_horizontal() -> None

Set slider orientation to horizontal.

Source code in prettyqt\widgets\styleoptionslider.py
def set_horizontal(self) -> None:
    """Set slider orientation to horizontal."""
    self.orientation = constants.HORIZONTAL

set_vertical() -> None

Set slider orientation to vertical.

Source code in prettyqt\widgets\styleoptionslider.py
def set_vertical(self) -> None:
    """Set slider orientation to vertical."""
    self.orientation = constants.VERTICAL

StyleOptionSpinBox

Bases: widgets.StyleOptionComplex, QtWidgets.QStyleOptionSpinBox

Source code in prettyqt\widgets\styleoptionspinbox.py
class StyleOptionSpinBox(widgets.StyleOptionComplex, QtWidgets.QStyleOptionSpinBox):
    pass

StyleOptionTab

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionTab

Source code in prettyqt\widgets\styleoptiontab.py
class StyleOptionTab(widgets.StyleOptionMixin, QtWidgets.QStyleOptionTab):
    pass

StyleOptionTabBarBase

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionTabBarBase

Source code in prettyqt\widgets\styleoptiontabbarbase.py
class StyleOptionTabBarBase(widgets.StyleOptionMixin, QtWidgets.QStyleOptionTabBarBase):
    pass

StyleOptionTabWidgetFrame

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionTabWidgetFrame

Source code in prettyqt\widgets\styleoptiontabwidgetframe.py
class StyleOptionTabWidgetFrame(
    widgets.StyleOptionMixin, QtWidgets.QStyleOptionTabWidgetFrame
):
    pass

StyleOptionTitleBar

Bases: widgets.StyleOptionComplex, QtWidgets.QStyleOptionTitleBar

Source code in prettyqt\widgets\styleoptiontitlebar.py
class StyleOptionTitleBar(widgets.StyleOptionComplex, QtWidgets.QStyleOptionTitleBar):
    pass

StyleOptionToolBar

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionToolBar

Source code in prettyqt\widgets\styleoptiontoolbar.py
class StyleOptionToolBar(widgets.StyleOptionMixin, QtWidgets.QStyleOptionToolBar):
    pass

StyleOptionToolBox

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionToolBox

Source code in prettyqt\widgets\styleoptiontoolbox.py
class StyleOptionToolBox(widgets.StyleOptionMixin, QtWidgets.QStyleOptionToolBox):
    def set_selected_position(self, position: SelectedPositionStr):
        self.selectedPosition = SELECTED_POSITION[position]

    def get_selected_position(self) -> SelectedPositionStr:
        return SELECTED_POSITION.inverse[self.selectedPosition]

get_selected_position() -> SelectedPositionStr

Source code in prettyqt\widgets\styleoptiontoolbox.py
def get_selected_position(self) -> SelectedPositionStr:
    return SELECTED_POSITION.inverse[self.selectedPosition]

set_selected_position(position: SelectedPositionStr)

Source code in prettyqt\widgets\styleoptiontoolbox.py
def set_selected_position(self, position: SelectedPositionStr):
    self.selectedPosition = SELECTED_POSITION[position]

StyleOptionToolButton

Bases: widgets.StyleOptionComplex, QtWidgets.QStyleOptionToolButton

Source code in prettyqt\widgets\styleoptiontoolbutton.py
class StyleOptionToolButton(widgets.StyleOptionComplex, QtWidgets.QStyleOptionToolButton):
    pass

StyleOptionViewItem

Bases: widgets.StyleOptionMixin, QtWidgets.QStyleOptionViewItem

Source code in prettyqt\widgets\styleoptionviewitem.py
class StyleOptionViewItem(widgets.StyleOptionMixin, QtWidgets.QStyleOptionViewItem):
    pass

StylePainter

Bases: gui.PainterMixin, QtWidgets.QStylePainter

Source code in prettyqt\widgets\stylepainter.py
class StylePainter(gui.PainterMixin, QtWidgets.QStylePainter):
    def draw_complex_control(
        self,
        control: widgets.style.ComplexControlStr,
        option: QtWidgets.QStyleOptionComplex,
    ):
        self.drawComplexControl(widgets.style.COMPLEX_CONTROL[control], option)

draw_complex_control(control: widgets.style.ComplexControlStr, option: QtWidgets.QStyleOptionComplex)

Source code in prettyqt\widgets\stylepainter.py
def draw_complex_control(
    self,
    control: widgets.style.ComplexControlStr,
    option: QtWidgets.QStyleOptionComplex,
):
    self.drawComplexControl(widgets.style.COMPLEX_CONTROL[control], option)

StyledItemDelegate

Bases: widgets.AbstractItemDelegateMixin, QtWidgets.QStyledItemDelegate

Source code in prettyqt\widgets\styleditemdelegate.py
class StyledItemDelegate(
    widgets.AbstractItemDelegateMixin, QtWidgets.QStyledItemDelegate
):
    pass

SwipeGesture

Bases: SwipeGestureMixin, QtWidgets.QSwipeGesture

Source code in prettyqt\widgets\swipegesture.py
class SwipeGesture(SwipeGestureMixin, QtWidgets.QSwipeGesture):
    pass

SystemTrayIcon

Bases: core.ObjectMixin, QtWidgets.QSystemTrayIcon

Source code in prettyqt\widgets\systemtrayicon.py
class SystemTrayIcon(core.ObjectMixin, QtWidgets.QSystemTrayIcon):
    def set_icon(self, icon: datatypes.IconType):
        """Set the system tray icon.

        Args:
            icon: icon to use
        """
        icon = iconprovider.get_icon(icon)
        self.setIcon(icon)

    def show_message(
        self,
        title: str,
        message: str = "",
        icon: datatypes.IconType = None,
        timeout: int = 10,
    ):
        if icon is None:
            ico = gui.Icon()
        if icon in MESSAGE_ICONS:
            ico = MESSAGE_ICONS[icon]
        else:
            ico = iconprovider.get_icon(icon)
        self.showMessage(title, message, ico, timeout * 1000)

set_icon(icon: datatypes.IconType)

Set the system tray icon.

Parameters:

Name Type Description Default
icon datatypes.IconType

icon to use

required
Source code in prettyqt\widgets\systemtrayicon.py
def set_icon(self, icon: datatypes.IconType):
    """Set the system tray icon.

    Args:
        icon: icon to use
    """
    icon = iconprovider.get_icon(icon)
    self.setIcon(icon)

show_message(title: str, message: str = '', icon: datatypes.IconType = None, timeout: int = 10)

Source code in prettyqt\widgets\systemtrayicon.py
def show_message(
    self,
    title: str,
    message: str = "",
    icon: datatypes.IconType = None,
    timeout: int = 10,
):
    if icon is None:
        ico = gui.Icon()
    if icon in MESSAGE_ICONS:
        ico = MESSAGE_ICONS[icon]
    else:
        ico = iconprovider.get_icon(icon)
    self.showMessage(title, message, ico, timeout * 1000)

TabBar

Bases: TabBarMixin, QtWidgets.QTabBar

Source code in prettyqt\widgets\tabbar.py
class TabBar(TabBarMixin, QtWidgets.QTabBar):
    pass

TabWidget

Bases: widgets.WidgetMixin, QtWidgets.QTabWidget

Widget for managing the tabs section.

Source code in prettyqt\widgets\tabwidget.py
class TabWidget(widgets.WidgetMixin, QtWidgets.QTabWidget):
    """Widget for managing the tabs section."""

    def __init__(
        self,
        parent: QtWidgets.QWidget | None = None,
        closable: bool = False,
        detachable: bool = False,
    ) -> None:
        # Basic initalization
        super().__init__(parent)
        self.tabCloseRequested.connect(self.remove_tab)
        self.tab_bar = widgets.TabBar(self)

        self.setTabBar(self.tab_bar)

        # Used to keep a reference to detached tabs since their QMainWindow
        # does not have a parent
        self.detached_tabs: dict[str, DetachedTab] = {}
        if detachable:
            self.set_detachable()
        self.set_closable(closable)

    def __len__(self) -> int:
        return self.count()

    def __getitem__(self, index: int) -> QtWidgets.QWidget:
        if isinstance(index, int):
            return self.widget(index)
        result = self.findChild(QtWidgets.QWidget, index)
        if result is None:
            raise KeyError("Widget not found")
        return result

    def __contains__(self, item: QtWidgets.QWidget):
        return self.indexOf(item) >= 0

    # def serialize_fields(self):
    #     return dict(
    #         tabbar=self.tabBar(),
    #         widgets=self.get_children(),
    #         movable=self.isMovable(),
    #         document_mode=self.documentMode(),
    #         current_index=self.currentIndex(),
    #         tab_shape=self.get_tab_shape(),
    #         # elide_mode=self.get_elide_mode(),
    #         icon_size=self.iconSize(),
    #         tab_position=self.get_tab_position(),
    #     )

    # def __setstate__(self, state):
    #     super().__setstate__(state)
    #     self.setTabBar(state["tabbar"])
    #     self.setDocumentMode(state.get("document_mode", False))
    #     self.setMovable(state.get("movable", False))
    #     self.set_tab_shape(state.get("tab_shape", "rounded"))
    #     self.setIconSize(state["icon_size"])
    #     for widget, name, icon, tooltip, whatsthis in state["widgets"]:
    #         i = self.add_tab(widget, name, icon)
    #         self.setTabToolTip(i, tooltip)
    #         self.setTabWhatsThis(i, whatsthis)
    #     self.setCurrentIndex(state.get("index", 0))

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    def update_tab_bar_visibility(self):
        """Update visibility of the tabBar depending of the number of tabs.

        0 or 1 tab -> tabBar hidden, 2+ tabs - >tabBar visible
        need to be called explicitly, or be connected to tabInserted/tabRemoved
        """
        self.tabBar().setVisible(self.count() > 1)

    def set_icon_size(self, size: int | datatypes.SizeType):
        """Set size of the icons."""
        if isinstance(size, int):
            size = core.Size(size, size)
        elif isinstance(size, tuple):
            size = core.Size(*size)
        self.setIconSize(size)

    def set_document_mode(self, state: bool = True) -> None:
        self.setDocumentMode(state)

    def set_tab_shape(self, shape: TabShapeStr):
        """Set tab shape for the tabwidget.

        Args:
            shape: tab shape to use

        Raises:
            InvalidParamError: tab shape does not exist
        """
        if shape not in TAB_SHAPES:
            raise InvalidParamError(shape, TAB_SHAPES)
        self.setTabShape(TAB_SHAPES[shape])

    def get_tab_shape(self) -> TabShapeStr:
        """Return tab shape.

        Returns:
            tab shape
        """
        return TAB_SHAPES.inverse[self.tabShape()]

    def set_tab_position(self, position: TabPositionStr):
        """Set tab position for the tabwidget.

        Args:
            position: tab position to use

        Raises:
            InvalidParamError: tab position does not exist
        """
        if position not in TAB_POSITION:
            raise InvalidParamError(position, TAB_POSITION)
        self.setTabPosition(TAB_POSITION[position])

    def get_tab_position(self) -> TabPositionStr:
        """Return tab position.

        Returns:
            tab position
        """
        return TAB_POSITION.inverse[self.tabPosition()]

    def get_children(self) -> list[tuple]:
        return [
            (
                self.widget(i),
                self.tabText(i),
                self.tab_icon(i),
                self.tabToolTip(i),
                self.tabWhatsThis(i),
            )
            for i in range(self.count())
        ]

    def tab_icon(self, i: int) -> gui.Icon | None:
        icon = self.tabIcon(i)
        return None if icon.isNull() else gui.Icon(icon)

    def set_detachable(self):
        self.tab_bar.on_detach.connect(self.detach_tab)
        core.CoreApplication.call_on_exit(self.close_detached_tabs)
        self.setMovable(True)

    def set_closable(self, closable: bool = True):
        self.setTabsClosable(closable)

    @core.Slot(int, QtCore.QPoint)
    def detach_tab(self, index: int, point: datatypes.PointType):
        """Detach tab by removing its contents and placing them in a DetachedTab window.

        Args:
            index (int): index location of the tab to be detached
            point (QtCore.QPoint): screen pos for creating the new DetachedTab window

        """
        # Get the tab content
        if isinstance(point, tuple):
            point = QtCore.QPoint(*point)
        name = self.tabText(index)
        icon = self.tab_icon(index) or self.window().windowIcon()
        widget = self.widget(index)

        try:
            widget_rect = widget.frameGeometry()
        except AttributeError:
            return

        # Create a new detached tab window
        detached_tab = DetachedTab(name, widget)
        detached_tab.set_modality("none")
        detached_tab.set_icon(icon)
        detached_tab.setGeometry(widget_rect)
        detached_tab.on_close.connect(self.attach_tab)
        detached_tab.move(point)
        detached_tab.show()

        # Create a reference to maintain access to the detached tab
        self.detached_tabs[name] = detached_tab

    def add_tab(
        self,
        item: QtWidgets.QWidget | QtWidgets.QLayout,
        label: str,
        icon: datatypes.IconType = None,
        position: int | None = None,
        show: bool = False,
    ) -> int:
        if isinstance(item, QtWidgets.QLayout):
            widget = widgets.Widget()
            widget.set_layout(item)
        else:
            widget = item
        if position is None:
            position = len(self)
        if not icon:
            index = self.insertTab(position, widget, label)
        else:
            icon = iconprovider.get_icon(icon)
            index = self.insertTab(position, widget, icon, label)
        if show:
            self.setCurrentIndex(index)
        return index

    def attach_tab(
        self,
        widget: QtWidgets.QWidget | QtWidgets.QLayout,
        name: str,
        icon: datatypes.IconType = None,
        insert_at: int | None = None,
    ):
        """Re-attach tab.

        Re-attach the tab by removing the content from the DetachedTab window,
        closing it, and placing the content back into the DetachableTabWidget.

        Args:
            widget (Union[QtWidgets.QWidget, QtWidgets.QLayout]): the content widget
                from the DetachedTab window
            name (str): the name of the detached tab
            icon (datatypes.IconType, optional): the window icon for the detached tab
            insert_at (Optional[int], optional): insert the re-attached tab at the
                given index
        """
        widget.setParent(self)

        # Remove the reference
        del self.detached_tabs[name]

        # Determine if the given image and the main window icon are the same.
        # If they are, then do not add the icon to the tab
        self.add_tab(widget, name, icon=icon, position=insert_at, show=True)

    def close_detached_tabs(self):
        """Close all tabs that are currently detached."""
        tabs = list(self.detached_tabs.values())
        for tab in tabs:
            tab.close()

    @core.Slot(int)
    def remove_tab(self, index: int):
        widget = self.widget(index)
        self.removeTab(index)
        if widget is not None:
            widget.deleteLater()

    @core.Slot(QtWidgets.QWidget, str)
    def open_widget(self, widget: QtWidgets.QWidget, title: str = "Unnamed"):
        """Create a tab containing delivered widget."""
        self.add_tab(widget, title, icon="mdi.widgets", show=True)

    def set_tab(self, index: int, position: str, widget: QtWidgets.QWidget | None = None):
        self.tabBar().set_tab(index, position, widget)

detached_tabs: dict[str, DetachedTab] = {} instance-attribute

tab_bar = widgets.TabBar(self) instance-attribute

__contains__(item: QtWidgets.QWidget)

Source code in prettyqt\widgets\tabwidget.py
def __contains__(self, item: QtWidgets.QWidget):
    return self.indexOf(item) >= 0

__getitem__(index: int) -> QtWidgets.QWidget

Source code in prettyqt\widgets\tabwidget.py
def __getitem__(self, index: int) -> QtWidgets.QWidget:
    if isinstance(index, int):
        return self.widget(index)
    result = self.findChild(QtWidgets.QWidget, index)
    if result is None:
        raise KeyError("Widget not found")
    return result

__init__(parent: QtWidgets.QWidget | None = None, closable: bool = False, detachable: bool = False) -> None

Source code in prettyqt\widgets\tabwidget.py
def __init__(
    self,
    parent: QtWidgets.QWidget | None = None,
    closable: bool = False,
    detachable: bool = False,
) -> None:
    # Basic initalization
    super().__init__(parent)
    self.tabCloseRequested.connect(self.remove_tab)
    self.tab_bar = widgets.TabBar(self)

    self.setTabBar(self.tab_bar)

    # Used to keep a reference to detached tabs since their QMainWindow
    # does not have a parent
    self.detached_tabs: dict[str, DetachedTab] = {}
    if detachable:
        self.set_detachable()
    self.set_closable(closable)

__len__() -> int

Source code in prettyqt\widgets\tabwidget.py
def __len__(self) -> int:
    return self.count()

add_tab(item: QtWidgets.QWidget | QtWidgets.QLayout, label: str, icon: datatypes.IconType = None, position: int | None = None, show: bool = False) -> int

Source code in prettyqt\widgets\tabwidget.py
def add_tab(
    self,
    item: QtWidgets.QWidget | QtWidgets.QLayout,
    label: str,
    icon: datatypes.IconType = None,
    position: int | None = None,
    show: bool = False,
) -> int:
    if isinstance(item, QtWidgets.QLayout):
        widget = widgets.Widget()
        widget.set_layout(item)
    else:
        widget = item
    if position is None:
        position = len(self)
    if not icon:
        index = self.insertTab(position, widget, label)
    else:
        icon = iconprovider.get_icon(icon)
        index = self.insertTab(position, widget, icon, label)
    if show:
        self.setCurrentIndex(index)
    return index

attach_tab(widget: QtWidgets.QWidget | QtWidgets.QLayout, name: str, icon: datatypes.IconType = None, insert_at: int | None = None)

Re-attach tab.

Re-attach the tab by removing the content from the DetachedTab window, closing it, and placing the content back into the DetachableTabWidget.

Parameters:

Name Type Description Default
widget Union[QtWidgets.QWidget, QtWidgets.QLayout]

the content widget from the DetachedTab window

required
name str

the name of the detached tab

required
icon datatypes.IconType

the window icon for the detached tab

None
insert_at Optional[int]

insert the re-attached tab at the given index

None
Source code in prettyqt\widgets\tabwidget.py
def attach_tab(
    self,
    widget: QtWidgets.QWidget | QtWidgets.QLayout,
    name: str,
    icon: datatypes.IconType = None,
    insert_at: int | None = None,
):
    """Re-attach tab.

    Re-attach the tab by removing the content from the DetachedTab window,
    closing it, and placing the content back into the DetachableTabWidget.

    Args:
        widget (Union[QtWidgets.QWidget, QtWidgets.QLayout]): the content widget
            from the DetachedTab window
        name (str): the name of the detached tab
        icon (datatypes.IconType, optional): the window icon for the detached tab
        insert_at (Optional[int], optional): insert the re-attached tab at the
            given index
    """
    widget.setParent(self)

    # Remove the reference
    del self.detached_tabs[name]

    # Determine if the given image and the main window icon are the same.
    # If they are, then do not add the icon to the tab
    self.add_tab(widget, name, icon=icon, position=insert_at, show=True)

close_detached_tabs()

Close all tabs that are currently detached.

Source code in prettyqt\widgets\tabwidget.py
def close_detached_tabs(self):
    """Close all tabs that are currently detached."""
    tabs = list(self.detached_tabs.values())
    for tab in tabs:
        tab.close()

detach_tab(index: int, point: datatypes.PointType)

Detach tab by removing its contents and placing them in a DetachedTab window.

Parameters:

Name Type Description Default
index int

index location of the tab to be detached

required
point QtCore.QPoint

screen pos for creating the new DetachedTab window

required
Source code in prettyqt\widgets\tabwidget.py
@core.Slot(int, QtCore.QPoint)
def detach_tab(self, index: int, point: datatypes.PointType):
    """Detach tab by removing its contents and placing them in a DetachedTab window.

    Args:
        index (int): index location of the tab to be detached
        point (QtCore.QPoint): screen pos for creating the new DetachedTab window

    """
    # Get the tab content
    if isinstance(point, tuple):
        point = QtCore.QPoint(*point)
    name = self.tabText(index)
    icon = self.tab_icon(index) or self.window().windowIcon()
    widget = self.widget(index)

    try:
        widget_rect = widget.frameGeometry()
    except AttributeError:
        return

    # Create a new detached tab window
    detached_tab = DetachedTab(name, widget)
    detached_tab.set_modality("none")
    detached_tab.set_icon(icon)
    detached_tab.setGeometry(widget_rect)
    detached_tab.on_close.connect(self.attach_tab)
    detached_tab.move(point)
    detached_tab.show()

    # Create a reference to maintain access to the detached tab
    self.detached_tabs[name] = detached_tab

get_children() -> list[tuple]

Source code in prettyqt\widgets\tabwidget.py
def get_children(self) -> list[tuple]:
    return [
        (
            self.widget(i),
            self.tabText(i),
            self.tab_icon(i),
            self.tabToolTip(i),
            self.tabWhatsThis(i),
        )
        for i in range(self.count())
    ]

get_tab_position() -> TabPositionStr

Return tab position.

Returns:

Type Description
TabPositionStr

tab position

Source code in prettyqt\widgets\tabwidget.py
def get_tab_position(self) -> TabPositionStr:
    """Return tab position.

    Returns:
        tab position
    """
    return TAB_POSITION.inverse[self.tabPosition()]

get_tab_shape() -> TabShapeStr

Return tab shape.

Returns:

Type Description
TabShapeStr

tab shape

Source code in prettyqt\widgets\tabwidget.py
def get_tab_shape(self) -> TabShapeStr:
    """Return tab shape.

    Returns:
        tab shape
    """
    return TAB_SHAPES.inverse[self.tabShape()]

open_widget(widget: QtWidgets.QWidget, title: str = 'Unnamed')

Create a tab containing delivered widget.

Source code in prettyqt\widgets\tabwidget.py
@core.Slot(QtWidgets.QWidget, str)
def open_widget(self, widget: QtWidgets.QWidget, title: str = "Unnamed"):
    """Create a tab containing delivered widget."""
    self.add_tab(widget, title, icon="mdi.widgets", show=True)

remove_tab(index: int)

Source code in prettyqt\widgets\tabwidget.py
@core.Slot(int)
def remove_tab(self, index: int):
    widget = self.widget(index)
    self.removeTab(index)
    if widget is not None:
        widget.deleteLater()

set_closable(closable: bool = True)

Source code in prettyqt\widgets\tabwidget.py
def set_closable(self, closable: bool = True):
    self.setTabsClosable(closable)

set_detachable()

Source code in prettyqt\widgets\tabwidget.py
def set_detachable(self):
    self.tab_bar.on_detach.connect(self.detach_tab)
    core.CoreApplication.call_on_exit(self.close_detached_tabs)
    self.setMovable(True)

set_document_mode(state: bool = True) -> None

Source code in prettyqt\widgets\tabwidget.py
def set_document_mode(self, state: bool = True) -> None:
    self.setDocumentMode(state)

set_icon_size(size: int | datatypes.SizeType)

Set size of the icons.

Source code in prettyqt\widgets\tabwidget.py
def set_icon_size(self, size: int | datatypes.SizeType):
    """Set size of the icons."""
    if isinstance(size, int):
        size = core.Size(size, size)
    elif isinstance(size, tuple):
        size = core.Size(*size)
    self.setIconSize(size)

set_tab(index: int, position: str, widget: QtWidgets.QWidget | None = None)

Source code in prettyqt\widgets\tabwidget.py
def set_tab(self, index: int, position: str, widget: QtWidgets.QWidget | None = None):
    self.tabBar().set_tab(index, position, widget)

set_tab_position(position: TabPositionStr)

Set tab position for the tabwidget.

Parameters:

Name Type Description Default
position TabPositionStr

tab position to use

required

Raises:

Type Description
InvalidParamError

tab position does not exist

Source code in prettyqt\widgets\tabwidget.py
def set_tab_position(self, position: TabPositionStr):
    """Set tab position for the tabwidget.

    Args:
        position: tab position to use

    Raises:
        InvalidParamError: tab position does not exist
    """
    if position not in TAB_POSITION:
        raise InvalidParamError(position, TAB_POSITION)
    self.setTabPosition(TAB_POSITION[position])

set_tab_shape(shape: TabShapeStr)

Set tab shape for the tabwidget.

Parameters:

Name Type Description Default
shape TabShapeStr

tab shape to use

required

Raises:

Type Description
InvalidParamError

tab shape does not exist

Source code in prettyqt\widgets\tabwidget.py
def set_tab_shape(self, shape: TabShapeStr):
    """Set tab shape for the tabwidget.

    Args:
        shape: tab shape to use

    Raises:
        InvalidParamError: tab shape does not exist
    """
    if shape not in TAB_SHAPES:
        raise InvalidParamError(shape, TAB_SHAPES)
    self.setTabShape(TAB_SHAPES[shape])

tab_icon(i: int) -> gui.Icon | None

Source code in prettyqt\widgets\tabwidget.py
def tab_icon(self, i: int) -> gui.Icon | None:
    icon = self.tabIcon(i)
    return None if icon.isNull() else gui.Icon(icon)

update_tab_bar_visibility()

Update visibility of the tabBar depending of the number of tabs.

0 or 1 tab -> tabBar hidden, 2+ tabs - >tabBar visible need to be called explicitly, or be connected to tabInserted/tabRemoved

Source code in prettyqt\widgets\tabwidget.py
def update_tab_bar_visibility(self):
    """Update visibility of the tabBar depending of the number of tabs.

    0 or 1 tab -> tabBar hidden, 2+ tabs - >tabBar visible
    need to be called explicitly, or be connected to tabInserted/tabRemoved
    """
    self.tabBar().setVisible(self.count() > 1)

TableView

Bases: TableViewMixin, QtWidgets.QTableView

Source code in prettyqt\widgets\tableview.py
class TableView(TableViewMixin, QtWidgets.QTableView):
    pass

TableViewMixin

Bases: widgets.AbstractItemViewMixin

Source code in prettyqt\widgets\tableview.py
class TableViewMixin(widgets.AbstractItemViewMixin):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        class_name = type(self).__name__
        self.set_id(class_name)
        self.setHorizontalHeader(widgets.HeaderView("horizontal", parent=self))
        self.setVerticalHeader(widgets.HeaderView("vertical", parent=self))
        self.setAlternatingRowColors(True)
        self.setWordWrap(False)

    @property
    def h_header(self):
        return self.horizontalHeader()

    @h_header.setter
    def h_header(self, header):
        self.setHorizontalHeader(header)

    @property
    def v_header(self):
        return self.verticalHeader()

    @v_header.setter
    def v_header(self, header):
        self.setVerticalHeader(header)

    def setup_list_style(self):
        self.set_selection_behaviour("rows")
        self.h_header.setStretchLastSection(True)
        self.v_header.set_resize_mode("fixed")
        self.v_header.set_default_section_size(28)

    def adapt_sizes(self):
        model = self.model()
        if model is not None and (model.rowCount() * model.columnCount()) < 1000:
            self.resizeColumnsToContents()
        else:
            self.h_header.resize_sections("interactive")

    def sort_by_column(self, column: int | None, ascending: bool = True):
        column = -1 if column is None else column
        order = constants.ASCENDING if ascending else constants.DESCENDING
        self.sortByColumn(column, order)

    def set_grid_style(self, style: constants.PenStyleStr):
        """Set grid style.

        Args:
            style: grid style to use

        Raises:
            InvalidParamError: invalid grid style
        """
        if style not in constants.PEN_STYLE:
            raise InvalidParamError(style, constants.PEN_STYLE)
        self.setGridStyle(constants.PEN_STYLE[style])

    def get_grid_style(self) -> constants.PenStyleStr:
        """Return grid style.

        Returns:
            grid style
        """
        return constants.PEN_STYLE.inverse[self.gridStyle()]

h_header writable property

v_header writable property

__init__(*args, **kwargs)

Source code in prettyqt\widgets\tableview.py
def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    class_name = type(self).__name__
    self.set_id(class_name)
    self.setHorizontalHeader(widgets.HeaderView("horizontal", parent=self))
    self.setVerticalHeader(widgets.HeaderView("vertical", parent=self))
    self.setAlternatingRowColors(True)
    self.setWordWrap(False)

adapt_sizes()

Source code in prettyqt\widgets\tableview.py
def adapt_sizes(self):
    model = self.model()
    if model is not None and (model.rowCount() * model.columnCount()) < 1000:
        self.resizeColumnsToContents()
    else:
        self.h_header.resize_sections("interactive")

get_grid_style() -> constants.PenStyleStr

Return grid style.

Returns:

Type Description
constants.PenStyleStr

grid style

Source code in prettyqt\widgets\tableview.py
def get_grid_style(self) -> constants.PenStyleStr:
    """Return grid style.

    Returns:
        grid style
    """
    return constants.PEN_STYLE.inverse[self.gridStyle()]

set_grid_style(style: constants.PenStyleStr)

Set grid style.

Parameters:

Name Type Description Default
style constants.PenStyleStr

grid style to use

required

Raises:

Type Description
InvalidParamError

invalid grid style

Source code in prettyqt\widgets\tableview.py
def set_grid_style(self, style: constants.PenStyleStr):
    """Set grid style.

    Args:
        style: grid style to use

    Raises:
        InvalidParamError: invalid grid style
    """
    if style not in constants.PEN_STYLE:
        raise InvalidParamError(style, constants.PEN_STYLE)
    self.setGridStyle(constants.PEN_STYLE[style])

setup_list_style()

Source code in prettyqt\widgets\tableview.py
def setup_list_style(self):
    self.set_selection_behaviour("rows")
    self.h_header.setStretchLastSection(True)
    self.v_header.set_resize_mode("fixed")
    self.v_header.set_default_section_size(28)

sort_by_column(column: int | None, ascending: bool = True)

Source code in prettyqt\widgets\tableview.py
def sort_by_column(self, column: int | None, ascending: bool = True):
    column = -1 if column is None else column
    order = constants.ASCENDING if ascending else constants.DESCENDING
    self.sortByColumn(column, order)

TableWidget

Bases: TableWidgetMixin, QtWidgets.QTableWidget

Source code in prettyqt\widgets\tablewidget.py
class TableWidget(TableWidgetMixin, QtWidgets.QTableWidget):
    pass

TableWidgetItem

Bases: QtWidgets.QTableWidgetItem

Source code in prettyqt\widgets\tablewidgetitem.py
class TableWidgetItem(QtWidgets.QTableWidgetItem):
    def __setitem__(self, index: int, value):
        self.setData(index, value)

    def __getitem__(self, index: int):
        return self.data(index)

    def serialize_fields(self):
        return dict(
            text=self.text(),
            tool_tip=self.toolTip(),
            status_tip=self.statusTip(),
            checkstate=self.get_checkstate(),
            icon=self.get_icon(),
            data=self.data(constants.USER_ROLE),  # type: ignore
        )

    def set_icon(self, icon: datatypes.IconType):
        """Set the icon for the action.

        Args:
            icon: icon to use
        """
        icon = iconprovider.get_icon(icon)
        self.setIcon(icon)

    def set_checkstate(self, state: constants.StateStr):
        """Set checkstate of the checkbox.

        Args:
            state: checkstate to use

        Raises:
            InvalidParamError: invalid checkstate
        """
        if state not in constants.STATE:
            raise InvalidParamError(state, constants.STATE)
        self.setCheckState(constants.STATE[state])

    def get_checkstate(self) -> constants.StateStr:
        """Return checkstate.

        Returns:
            checkstate
        """
        return constants.STATE.inverse[self.checkState()]

    def set_text_alignment(
        self,
        horizontal: constants.HorizontalAlignmentStr | None = None,
        vertical: constants.VerticalAlignmentStr | None = None,
    ):
        """Set text alignment of the checkbox.

        Args:
            horizontal: horizontal text alignment to use
            vertical: vertical text alignment to use

        Raises:
            InvalidParamError: invalid text alignment
        """
        match horizontal, vertical:
            case None, None:
                return
            case None, _:
                flag = constants.V_ALIGNMENT[vertical]
            case _, None:
                flag = constants.H_ALIGNMENT[horizontal]
            case _, _:
                flag = constants.V_ALIGNMENT[vertical] | constants.H_ALIGNMENT[horizontal]
        self.setTextAlignment(flag)

    def get_background(self) -> gui.Brush:
        return gui.Brush(self.background())

    def get_foreground(self) -> gui.Brush:
        return gui.Brush(self.foreground())

    def get_font(self) -> gui.Font:
        return gui.Font(self.font())

    def get_icon(self) -> gui.Icon | None:
        icon = self.icon()
        return None if icon.isNull() else gui.Icon(icon)

    def set_tooltip(
        self,
        tooltip: str | datatypes.PathType,
        size: datatypes.SizeType | None = None,
    ):
        if isinstance(tooltip, os.PathLike):
            path = os.fspath(tooltip)
            if size is None:
                tooltip = f"<img src={path!r}>"
            else:
                if isinstance(size, QtCore.QSize):
                    size = (size.width(), size.height())
                tooltip = f'<img src={path!r} width="{size[0]}" height="{size[1]}">'
        self.setToolTip(tooltip)

__getitem__(index: int)

Source code in prettyqt\widgets\tablewidgetitem.py
def __getitem__(self, index: int):
    return self.data(index)

__setitem__(index: int, value)

Source code in prettyqt\widgets\tablewidgetitem.py
def __setitem__(self, index: int, value):
    self.setData(index, value)

get_background() -> gui.Brush

Source code in prettyqt\widgets\tablewidgetitem.py
def get_background(self) -> gui.Brush:
    return gui.Brush(self.background())

get_checkstate() -> constants.StateStr

Return checkstate.

Returns:

Type Description
constants.StateStr

checkstate

Source code in prettyqt\widgets\tablewidgetitem.py
def get_checkstate(self) -> constants.StateStr:
    """Return checkstate.

    Returns:
        checkstate
    """
    return constants.STATE.inverse[self.checkState()]

get_font() -> gui.Font

Source code in prettyqt\widgets\tablewidgetitem.py
def get_font(self) -> gui.Font:
    return gui.Font(self.font())

get_foreground() -> gui.Brush

Source code in prettyqt\widgets\tablewidgetitem.py
def get_foreground(self) -> gui.Brush:
    return gui.Brush(self.foreground())

get_icon() -> gui.Icon | None

Source code in prettyqt\widgets\tablewidgetitem.py
def get_icon(self) -> gui.Icon | None:
    icon = self.icon()
    return None if icon.isNull() else gui.Icon(icon)

serialize_fields()

Source code in prettyqt\widgets\tablewidgetitem.py
def serialize_fields(self):
    return dict(
        text=self.text(),
        tool_tip=self.toolTip(),
        status_tip=self.statusTip(),
        checkstate=self.get_checkstate(),
        icon=self.get_icon(),
        data=self.data(constants.USER_ROLE),  # type: ignore
    )

set_checkstate(state: constants.StateStr)

Set checkstate of the checkbox.

Parameters:

Name Type Description Default
state constants.StateStr

checkstate to use

required

Raises:

Type Description
InvalidParamError

invalid checkstate

Source code in prettyqt\widgets\tablewidgetitem.py
def set_checkstate(self, state: constants.StateStr):
    """Set checkstate of the checkbox.

    Args:
        state: checkstate to use

    Raises:
        InvalidParamError: invalid checkstate
    """
    if state not in constants.STATE:
        raise InvalidParamError(state, constants.STATE)
    self.setCheckState(constants.STATE[state])

set_icon(icon: datatypes.IconType)

Set the icon for the action.

Parameters:

Name Type Description Default
icon datatypes.IconType

icon to use

required
Source code in prettyqt\widgets\tablewidgetitem.py
def set_icon(self, icon: datatypes.IconType):
    """Set the icon for the action.

    Args:
        icon: icon to use
    """
    icon = iconprovider.get_icon(icon)
    self.setIcon(icon)

set_text_alignment(horizontal: constants.HorizontalAlignmentStr | None = None, vertical: constants.VerticalAlignmentStr | None = None)

Set text alignment of the checkbox.

Parameters:

Name Type Description Default
horizontal constants.HorizontalAlignmentStr | None

horizontal text alignment to use

None
vertical constants.VerticalAlignmentStr | None

vertical text alignment to use

None

Raises:

Type Description
InvalidParamError

invalid text alignment

Source code in prettyqt\widgets\tablewidgetitem.py
def set_text_alignment(
    self,
    horizontal: constants.HorizontalAlignmentStr | None = None,
    vertical: constants.VerticalAlignmentStr | None = None,
):
    """Set text alignment of the checkbox.

    Args:
        horizontal: horizontal text alignment to use
        vertical: vertical text alignment to use

    Raises:
        InvalidParamError: invalid text alignment
    """
    match horizontal, vertical:
        case None, None:
            return
        case None, _:
            flag = constants.V_ALIGNMENT[vertical]
        case _, None:
            flag = constants.H_ALIGNMENT[horizontal]
        case _, _:
            flag = constants.V_ALIGNMENT[vertical] | constants.H_ALIGNMENT[horizontal]
    self.setTextAlignment(flag)

set_tooltip(tooltip: str | datatypes.PathType, size: datatypes.SizeType | None = None)

Source code in prettyqt\widgets\tablewidgetitem.py
def set_tooltip(
    self,
    tooltip: str | datatypes.PathType,
    size: datatypes.SizeType | None = None,
):
    if isinstance(tooltip, os.PathLike):
        path = os.fspath(tooltip)
        if size is None:
            tooltip = f"<img src={path!r}>"
        else:
            if isinstance(size, QtCore.QSize):
                size = (size.width(), size.height())
            tooltip = f'<img src={path!r} width="{size[0]}" height="{size[1]}">'
    self.setToolTip(tooltip)

TableWidgetSelectionRange

Bases: QtWidgets.QTableWidgetSelectionRange

Source code in prettyqt\widgets\tablewidgetselectionrange.py
class TableWidgetSelectionRange(QtWidgets.QTableWidgetSelectionRange):
    def __repr__(self):
        return get_repr(
            self, self.topRow(), self.leftColumn(), self.bottomRow(), self.rightColumn()
        )

    def __eq__(self, other: object):
        return (
            (
                self.topRow() == other.topRow()
                and self.bottomRow() == other.bottomRow()
                and self.leftColumn() == other.leftColumn()
                and self.rightColumn() == other.rightColumn()
            )
            if isinstance(other, TableWidgetSelectionRange)
            else False
        )

    def __or__(
        self, other: QtWidgets.QTableWidgetSelectionRange
    ) -> TableWidgetSelectionRange:
        return TableWidgetSelectionRange(
            min(self.topRow(), other.topRow()),
            min(self.leftColumn(), other.leftColumn()),
            max(self.bottomRow(), other.bottomRow()),
            max(self.rightColumn(), other.rightColumn()),
        )

    def __and__(
        self, other: QtWidgets.QTableWidgetSelectionRange
    ) -> TableWidgetSelectionRange:
        return (
            TableWidgetSelectionRange()
            if other.topRow() > self.bottomRow()
            and other.bottomRow() < self.topRow()
            and other.leftColumn() > self.rightColumn()
            and other.rightColumn() < self.leftColumn()
            else TableWidgetSelectionRange(
                max(self.topRow(), other.topRow()),
                max(self.leftColumn(), other.leftColumn()),
                min(self.bottomRow(), other.bottomRow()),
                min(self.rightColumn(), other.rightColumn()),
            )
        )

__and__(other: QtWidgets.QTableWidgetSelectionRange) -> TableWidgetSelectionRange

Source code in prettyqt\widgets\tablewidgetselectionrange.py
def __and__(
    self, other: QtWidgets.QTableWidgetSelectionRange
) -> TableWidgetSelectionRange:
    return (
        TableWidgetSelectionRange()
        if other.topRow() > self.bottomRow()
        and other.bottomRow() < self.topRow()
        and other.leftColumn() > self.rightColumn()
        and other.rightColumn() < self.leftColumn()
        else TableWidgetSelectionRange(
            max(self.topRow(), other.topRow()),
            max(self.leftColumn(), other.leftColumn()),
            min(self.bottomRow(), other.bottomRow()),
            min(self.rightColumn(), other.rightColumn()),
        )
    )

__eq__(other: object)

Source code in prettyqt\widgets\tablewidgetselectionrange.py
def __eq__(self, other: object):
    return (
        (
            self.topRow() == other.topRow()
            and self.bottomRow() == other.bottomRow()
            and self.leftColumn() == other.leftColumn()
            and self.rightColumn() == other.rightColumn()
        )
        if isinstance(other, TableWidgetSelectionRange)
        else False
    )

__or__(other: QtWidgets.QTableWidgetSelectionRange) -> TableWidgetSelectionRange

Source code in prettyqt\widgets\tablewidgetselectionrange.py
def __or__(
    self, other: QtWidgets.QTableWidgetSelectionRange
) -> TableWidgetSelectionRange:
    return TableWidgetSelectionRange(
        min(self.topRow(), other.topRow()),
        min(self.leftColumn(), other.leftColumn()),
        max(self.bottomRow(), other.bottomRow()),
        max(self.rightColumn(), other.rightColumn()),
    )

__repr__()

Source code in prettyqt\widgets\tablewidgetselectionrange.py
def __repr__(self):
    return get_repr(
        self, self.topRow(), self.leftColumn(), self.bottomRow(), self.rightColumn()
    )

TapAndHoldGesture

Bases: widgets.GestureMixin, QtWidgets.QTapAndHoldGesture

Source code in prettyqt\widgets\tapandholdgesture.py
7
8
9
class TapAndHoldGesture(widgets.GestureMixin, QtWidgets.QTapAndHoldGesture):
    def get_position(self) -> core.PointF:
        return core.PointF(self.position())

get_position() -> core.PointF

Source code in prettyqt\widgets\tapandholdgesture.py
def get_position(self) -> core.PointF:
    return core.PointF(self.position())

TapGesture

Bases: widgets.GestureMixin, QtWidgets.QTapGesture

Source code in prettyqt\widgets\tapgesture.py
7
8
9
class TapGesture(widgets.GestureMixin, QtWidgets.QTapGesture):
    def get_position(self) -> core.PointF:
        return core.PointF(self.position())

get_position() -> core.PointF

Source code in prettyqt\widgets\tapgesture.py
def get_position(self) -> core.PointF:
    return core.PointF(self.position())

TextBrowser

Bases: widgets.TextEditMixin, QtWidgets.QTextBrowser

Source code in prettyqt\widgets\textbrowser.py
class TextBrowser(widgets.TextEditMixin, QtWidgets.QTextBrowser):
    value_changed = core.Signal(str)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.setOpenExternalLinks(True)

    # def dragEnterEvent(self, event):
    #     u = event.mimeData().urls()
    #     for url in u:
    #         file_path = os.path.abspath(url.toLocalFile())

    #         ext = file_path.split(".")[-1]
    #         if ext in ["txt", "md", "markdown"]:
    #             event.accept()
    #         else:
    #             event.ignore()

    # def dropEvent(self, event):
    #     event.accept()
    #     self.show_markdown_file(self.filePath)

    def set_markdown_file(self, file_path: datatypes.PathType):
        file_path = pathlib.Path(file_path)
        with file_path.open() as f:
            file_content = f.read()
        self.set_markdown(file_content)

    def set_markdown(self, source: str):
        self.setMarkdown(source)

    def set_rst_file(self, file_path: datatypes.PathType):
        file_path = pathlib.Path(file_path)
        with file_path.open() as f:
            file_content = f.read()
        self.set_rst(file_content)

    def set_rst(self, source: str):
        import docutils.core

        html = docutils.core.publish_string(source, writer_name="html")
        self.setHtml(str(html))

    def get_search_paths(self) -> list[pathlib.Path]:
        return [pathlib.Path(p) for p in self.searchPaths()]

    def set_search_paths(self, paths: list[datatypes.PathType]):
        self.setSearchPaths([os.fspath(p) for p in paths])

value_changed = core.Signal(str) class-attribute

__init__(*args, **kwargs)

Source code in prettyqt\widgets\textbrowser.py
def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.setOpenExternalLinks(True)

get_search_paths() -> list[pathlib.Path]

Source code in prettyqt\widgets\textbrowser.py
def get_search_paths(self) -> list[pathlib.Path]:
    return [pathlib.Path(p) for p in self.searchPaths()]

set_markdown(source: str)

Source code in prettyqt\widgets\textbrowser.py
def set_markdown(self, source: str):
    self.setMarkdown(source)

set_markdown_file(file_path: datatypes.PathType)

Source code in prettyqt\widgets\textbrowser.py
def set_markdown_file(self, file_path: datatypes.PathType):
    file_path = pathlib.Path(file_path)
    with file_path.open() as f:
        file_content = f.read()
    self.set_markdown(file_content)

set_rst(source: str)

Source code in prettyqt\widgets\textbrowser.py
def set_rst(self, source: str):
    import docutils.core

    html = docutils.core.publish_string(source, writer_name="html")
    self.setHtml(str(html))

set_rst_file(file_path: datatypes.PathType)

Source code in prettyqt\widgets\textbrowser.py
def set_rst_file(self, file_path: datatypes.PathType):
    file_path = pathlib.Path(file_path)
    with file_path.open() as f:
        file_content = f.read()
    self.set_rst(file_content)

set_search_paths(paths: list[datatypes.PathType])

Source code in prettyqt\widgets\textbrowser.py
def set_search_paths(self, paths: list[datatypes.PathType]):
    self.setSearchPaths([os.fspath(p) for p in paths])

TextEdit

Bases: TextEditMixin, QtWidgets.QTextEdit

Source code in prettyqt\widgets\textedit.py
class TextEdit(TextEditMixin, QtWidgets.QTextEdit):
    pass

TextEditMixin

Bases: widgets.AbstractScrollAreaMixin

Source code in prettyqt\widgets\textedit.py
class TextEditMixin(widgets.AbstractScrollAreaMixin):
    value_changed = core.Signal(str)

    def __init__(self, *args, **kwargs) -> None:
        super().__init__(*args, **kwargs)
        self.textChanged.connect(self.on_value_change)

    def __add__(self, other: str) -> TextEdit:
        self.append_text(other)
        return self

    def on_value_change(self) -> None:
        self.value_changed.emit(self.text())

    @contextlib.contextmanager
    def create_cursor(self) -> Iterator[gui.TextCursor]:
        cursor = gui.TextCursor(self.document())
        yield cursor
        self.setTextCursor(cursor)

    def get_text_cursor(self) -> gui.TextCursor:
        return gui.TextCursor(self.textCursor())

    def set_text(self, text: str) -> None:
        self.setPlainText(text)

    def append_text(self, text: str) -> None:
        self.append(text)

    def text(self) -> str:
        return self.toPlainText()

    def select_text(self, start: int, end: int) -> None:
        with self.create_cursor() as c:
            c.select_text(start, end)

    def set_read_only(self, value: bool = True) -> None:
        self.setReadOnly(value)

    def set_text_color(self, color: datatypes.ColorType) -> None:
        color = colors.get_color(color)
        self.setTextColor(color)

    def set_line_wrap_mode(self, mode: LineWrapModeStr):
        """Set line wrap mode.

        Args:
            mode: line wrap mode to use

        Raises:
            InvalidParamError: line wrap mode does not exist
        """
        if mode not in LINE_WRAP_MODE:
            raise InvalidParamError(mode, LINE_WRAP_MODE)
        self.setLineWrapMode(LINE_WRAP_MODE[mode])

    def get_line_wrap_mode(self) -> LineWrapModeStr:
        """Get the current wrap mode.

        Returns:
            Wrap mode
        """
        return LINE_WRAP_MODE.inverse[self.lineWrapMode()]

    def set_auto_formatting(self, mode: AutoFormattingStr):
        """Set auto formatting mode.

        Args:
            mode: auto formatting mode to use

        Raises:
            InvalidParamError: auto formatting mode does not exist
        """
        if mode not in AUTO_FORMATTING:
            raise InvalidParamError(mode, AUTO_FORMATTING)
        self.setAutoFormatting(AUTO_FORMATTING[mode])

    def get_auto_formatting(self) -> AutoFormattingStr:
        """Get the current auto formatting mode.

        Returns:
            Auto formatting mode
        """
        return AUTO_FORMATTING.inverse[self.autoFormatting()]

    def set_word_wrap_mode(self, mode: gui.textoption.WordWrapModeStr):
        """Set word wrap mode.

        Args:
            mode: word wrap mode to use

        Raises:
            InvalidParamError: wrap mode does not exist
        """
        if mode not in gui.textoption.WORD_WRAP_MODE:
            raise InvalidParamError(mode, gui.textoption.WORD_WRAP_MODE)
        self.setWordWrapMode(gui.textoption.WORD_WRAP_MODE[mode])

    def get_word_wrap_mode(self) -> gui.textoption.WordWrapModeStr:
        """Get the current word wrap mode.

        Returns:
            Word wrap mode
        """
        return gui.textoption.WORD_WRAP_MODE.inverse[self.wordWrapMode()]

value_changed = core.Signal(str) class-attribute

__add__(other: str) -> TextEdit

Source code in prettyqt\widgets\textedit.py
def __add__(self, other: str) -> TextEdit:
    self.append_text(other)
    return self

__init__(*args, **kwargs) -> None

Source code in prettyqt\widgets\textedit.py
def __init__(self, *args, **kwargs) -> None:
    super().__init__(*args, **kwargs)
    self.textChanged.connect(self.on_value_change)

append_text(text: str) -> None

Source code in prettyqt\widgets\textedit.py
def append_text(self, text: str) -> None:
    self.append(text)

create_cursor() -> Iterator[gui.TextCursor]

Source code in prettyqt\widgets\textedit.py
@contextlib.contextmanager
def create_cursor(self) -> Iterator[gui.TextCursor]:
    cursor = gui.TextCursor(self.document())
    yield cursor
    self.setTextCursor(cursor)

get_auto_formatting() -> AutoFormattingStr

Get the current auto formatting mode.

Returns:

Type Description
AutoFormattingStr

Auto formatting mode

Source code in prettyqt\widgets\textedit.py
def get_auto_formatting(self) -> AutoFormattingStr:
    """Get the current auto formatting mode.

    Returns:
        Auto formatting mode
    """
    return AUTO_FORMATTING.inverse[self.autoFormatting()]

get_line_wrap_mode() -> LineWrapModeStr

Get the current wrap mode.

Returns:

Type Description
LineWrapModeStr

Wrap mode

Source code in prettyqt\widgets\textedit.py
def get_line_wrap_mode(self) -> LineWrapModeStr:
    """Get the current wrap mode.

    Returns:
        Wrap mode
    """
    return LINE_WRAP_MODE.inverse[self.lineWrapMode()]

get_text_cursor() -> gui.TextCursor

Source code in prettyqt\widgets\textedit.py
def get_text_cursor(self) -> gui.TextCursor:
    return gui.TextCursor(self.textCursor())

get_word_wrap_mode() -> gui.textoption.WordWrapModeStr

Get the current word wrap mode.

Returns:

Type Description
gui.textoption.WordWrapModeStr

Word wrap mode

Source code in prettyqt\widgets\textedit.py
def get_word_wrap_mode(self) -> gui.textoption.WordWrapModeStr:
    """Get the current word wrap mode.

    Returns:
        Word wrap mode
    """
    return gui.textoption.WORD_WRAP_MODE.inverse[self.wordWrapMode()]

on_value_change() -> None

Source code in prettyqt\widgets\textedit.py
def on_value_change(self) -> None:
    self.value_changed.emit(self.text())

select_text(start: int, end: int) -> None

Source code in prettyqt\widgets\textedit.py
def select_text(self, start: int, end: int) -> None:
    with self.create_cursor() as c:
        c.select_text(start, end)

set_auto_formatting(mode: AutoFormattingStr)

Set auto formatting mode.

Parameters:

Name Type Description Default
mode AutoFormattingStr

auto formatting mode to use

required

Raises:

Type Description
InvalidParamError

auto formatting mode does not exist

Source code in prettyqt\widgets\textedit.py
def set_auto_formatting(self, mode: AutoFormattingStr):
    """Set auto formatting mode.

    Args:
        mode: auto formatting mode to use

    Raises:
        InvalidParamError: auto formatting mode does not exist
    """
    if mode not in AUTO_FORMATTING:
        raise InvalidParamError(mode, AUTO_FORMATTING)
    self.setAutoFormatting(AUTO_FORMATTING[mode])

set_line_wrap_mode(mode: LineWrapModeStr)

Set line wrap mode.

Parameters:

Name Type Description Default
mode LineWrapModeStr

line wrap mode to use

required

Raises:

Type Description
InvalidParamError

line wrap mode does not exist

Source code in prettyqt\widgets\textedit.py
def set_line_wrap_mode(self, mode: LineWrapModeStr):
    """Set line wrap mode.

    Args:
        mode: line wrap mode to use

    Raises:
        InvalidParamError: line wrap mode does not exist
    """
    if mode not in LINE_WRAP_MODE:
        raise InvalidParamError(mode, LINE_WRAP_MODE)
    self.setLineWrapMode(LINE_WRAP_MODE[mode])

set_read_only(value: bool = True) -> None

Source code in prettyqt\widgets\textedit.py
def set_read_only(self, value: bool = True) -> None:
    self.setReadOnly(value)

set_text(text: str) -> None

Source code in prettyqt\widgets\textedit.py
def set_text(self, text: str) -> None:
    self.setPlainText(text)

set_text_color(color: datatypes.ColorType) -> None

Source code in prettyqt\widgets\textedit.py
def set_text_color(self, color: datatypes.ColorType) -> None:
    color = colors.get_color(color)
    self.setTextColor(color)

set_word_wrap_mode(mode: gui.textoption.WordWrapModeStr)

Set word wrap mode.

Parameters:

Name Type Description Default
mode gui.textoption.WordWrapModeStr

word wrap mode to use

required

Raises:

Type Description
InvalidParamError

wrap mode does not exist

Source code in prettyqt\widgets\textedit.py
def set_word_wrap_mode(self, mode: gui.textoption.WordWrapModeStr):
    """Set word wrap mode.

    Args:
        mode: word wrap mode to use

    Raises:
        InvalidParamError: wrap mode does not exist
    """
    if mode not in gui.textoption.WORD_WRAP_MODE:
        raise InvalidParamError(mode, gui.textoption.WORD_WRAP_MODE)
    self.setWordWrapMode(gui.textoption.WORD_WRAP_MODE[mode])

text() -> str

Source code in prettyqt\widgets\textedit.py
def text(self) -> str:
    return self.toPlainText()

TimeEdit

Bases: widgets.DateTimeEditMixin, QtWidgets.QTimeEdit

Source code in prettyqt\widgets\timeedit.py
class TimeEdit(widgets.DateTimeEditMixin, QtWidgets.QTimeEdit):
    value_changed = core.Signal(datetime.datetime)

    def set_range(self, lower: datatypes.TimeType, upper: datatypes.TimeType):
        if isinstance(lower, str):
            lower = core.Time.fromString(lower)
        else:
            lower = core.Time(lower)
        if isinstance(upper, str):
            upper = core.Time.fromString(upper)
        else:
            upper = core.Time(upper)
        self.setToolTip(f"{lower.toString()} <= x <= {upper.toString()}")
        self.setTimeRange(lower, upper)  # type: ignore

    def get_value(self) -> datetime.time:
        return self.get_time()

    def set_value(self, value: datatypes.TimeType):
        if isinstance(value, str):
            value = core.Time.fromString(value)
        return self.setTime(value)  # type: ignore

value_changed = core.Signal(datetime.datetime) class-attribute

get_value() -> datetime.time

Source code in prettyqt\widgets\timeedit.py
def get_value(self) -> datetime.time:
    return self.get_time()

set_range(lower: datatypes.TimeType, upper: datatypes.TimeType)

Source code in prettyqt\widgets\timeedit.py
def set_range(self, lower: datatypes.TimeType, upper: datatypes.TimeType):
    if isinstance(lower, str):
        lower = core.Time.fromString(lower)
    else:
        lower = core.Time(lower)
    if isinstance(upper, str):
        upper = core.Time.fromString(upper)
    else:
        upper = core.Time(upper)
    self.setToolTip(f"{lower.toString()} <= x <= {upper.toString()}")
    self.setTimeRange(lower, upper)  # type: ignore

set_value(value: datatypes.TimeType)

Source code in prettyqt\widgets\timeedit.py
def set_value(self, value: datatypes.TimeType):
    if isinstance(value, str):
        value = core.Time.fromString(value)
    return self.setTime(value)  # type: ignore

ToolBar

Bases: ToolBarMixin, QtWidgets.QToolBar

Source code in prettyqt\widgets\toolbar.py
class ToolBar(ToolBarMixin, QtWidgets.QToolBar):
    pass

ToolBox

Bases: widgets.FrameMixin, QtWidgets.QToolBox

Source code in prettyqt\widgets\toolbox.py
class ToolBox(widgets.FrameMixin, QtWidgets.QToolBox):
    def __getitem__(self, index: int | str) -> QtWidgets.QWidget:
        if isinstance(index, int):
            return self.widget(index)
        result = self.find_child(QtWidgets.QWidget, index)
        if result is None:
            raise KeyError("Widget not found")
        return result

    def __delitem__(self, index: int):
        self.removeItem(index)

    # def serialize_fields(self):
    #     children = []
    #     for i, widget in enumerate(self.get_children()):
    #         dct = dict(
    #             widget=widget,
    #             icon=self.item_icon(i),
    #             text=self.itemText(i),
    #             enabled=self.isItemEnabled(i),
    #             tool_tip=self.itemToolTip(i),
    #         )
    #         children.append(dct)
    #     return dict(items=children, current_index=self.currentIndex())

    # def __setstate__(self, state):
    #     for i, item in enumerate(state["items"]):
    #         self.addItem(item["widget"], item["icon"], item["text"])
    #         self.setItemEnabled(i, item["enabled"])
    #         self.setItemToolTip(i, item["tool_tip"])
    #     self.setCurrentIndex(state["current_index"])

    # def __reduce__(self):
    #     return type(self), (), self.__getstate__()

    def __iter__(self) -> Iterator[QtWidgets.QWidget]:
        return iter(self.get_children())

    def __contains__(self, item: QtWidgets.QWidget):
        return self.indexOf(item) >= 0

    def get_children(self) -> list[QtWidgets.QWidget]:
        return [self.widget(i) for i in range(self.count())]

    def add_widget(
        self,
        widget: QtWidgets.QWidget,
        title: str | None = None,
        icon: datatypes.IconType = None,
    ):
        if title is None:
            title = widget.objectName()
        if icon:
            icon = iconprovider.get_icon(icon)
            self.addItem(widget, icon, title)
        else:
            self.addItem(widget, title)

    def item_icon(self, index: int) -> gui.Icon | None:
        icon = self.itemIcon(index)
        return None if icon.isNull() else gui.Icon(icon)

__contains__(item: QtWidgets.QWidget)

Source code in prettyqt\widgets\toolbox.py
def __contains__(self, item: QtWidgets.QWidget):
    return self.indexOf(item) >= 0

__delitem__(index: int)

Source code in prettyqt\widgets\toolbox.py
def __delitem__(self, index: int):
    self.removeItem(index)

__getitem__(index: int | str) -> QtWidgets.QWidget

Source code in prettyqt\widgets\toolbox.py
def __getitem__(self, index: int | str) -> QtWidgets.QWidget:
    if isinstance(index, int):
        return self.widget(index)
    result = self.find_child(QtWidgets.QWidget, index)
    if result is None:
        raise KeyError("Widget not found")
    return result

__iter__() -> Iterator[QtWidgets.QWidget]

Source code in prettyqt\widgets\toolbox.py
def __iter__(self) -> Iterator[QtWidgets.QWidget]:
    return iter(self.get_children())

add_widget(widget: QtWidgets.QWidget, title: str | None = None, icon: datatypes.IconType = None)

Source code in prettyqt\widgets\toolbox.py
def add_widget(
    self,
    widget: QtWidgets.QWidget,
    title: str | None = None,
    icon: datatypes.IconType = None,
):
    if title is None:
        title = widget.objectName()
    if icon:
        icon = iconprovider.get_icon(icon)
        self.addItem(widget, icon, title)
    else:
        self.addItem(widget, title)

get_children() -> list[QtWidgets.QWidget]

Source code in prettyqt\widgets\toolbox.py
def get_children(self) -> list[QtWidgets.QWidget]:
    return [self.widget(i) for i in range(self.count())]

item_icon(index: int) -> gui.Icon | None

Source code in prettyqt\widgets\toolbox.py
def item_icon(self, index: int) -> gui.Icon | None:
    icon = self.itemIcon(index)
    return None if icon.isNull() else gui.Icon(icon)

ToolButton

Bases: widgets.AbstractButtonMixin, QtWidgets.QToolButton

Source code in prettyqt\widgets\toolbutton.py
class ToolButton(widgets.AbstractButtonMixin, QtWidgets.QToolButton):
    def __getitem__(self, item: str) -> QtWidgets.QAction:
        menu = self.menu()
        return menu[item]

    # def set_menu(self, menu: QtWidgets.QMenu):
    #     menu.setParent(self)
    #     self.setMenu(menu)

    @classmethod
    def for_menu(cls, menu: QtWidgets.QMenu, icon: datatypes.IconType = None):
        btn = cls()
        btn.setMenu(menu)
        # btn.set_title(menu.title())
        btn.set_popup_mode("instant")
        btn.set_icon(icon)
        return btn

    def set_default_action(self, action):
        self.setDefaultAction(action)

    def set_popup_mode(self, mode: PopupModeStr):
        """Set the popup mode of the toolbutton.

        Args:
            mode: popup mode to use

        Raises:
            InvalidParamError: invalid popup mode
        """
        if mode not in POPUP_MODE:
            raise InvalidParamError(mode, POPUP_MODE)
        self.setPopupMode(POPUP_MODE[mode])

    def get_popup_mode(self) -> PopupModeStr:
        """Return popup mode.

        Returns:
            popup mode
        """
        return POPUP_MODE.inverse[self.popupMode()]

    def set_arrow_type(self, mode: constants.ArrowTypeStr):
        """Set the arrow type of the toolbutton.

        Args:
            mode: arrow type to use

        Raises:
            InvalidParamError: invalid arrow type
        """
        if mode not in constants.ARROW_TYPE:
            raise InvalidParamError(mode, constants.ARROW_TYPE)
        self.setArrowType(constants.ARROW_TYPE[mode])

    def get_arrow_type(self) -> constants.ArrowTypeStr:
        """Return arrow type.

        Returns:
            arrow type
        """
        return constants.ARROW_TYPE.inverse[self.arrowType()]

    def set_style(self, style: constants.ToolButtonStyleStr):
        """Set the toolbutton style.

        Args:
            style: style to use

        Raises:
            InvalidParamError: invalid style
        """
        if style not in constants.TOOLBUTTON_STYLE:
            raise InvalidParamError(style, constants.TOOLBUTTON_STYLE)
        self.setToolButtonStyle(constants.TOOLBUTTON_STYLE[style])

    def get_style(self) -> constants.ToolButtonStyleStr:
        """Return toolbutton style.

        Returns:
            toolbutton style
        """
        return constants.TOOLBUTTON_STYLE.inverse[self.toolButtonStyle()]

__getitem__(item: str) -> QtWidgets.QAction

Source code in prettyqt\widgets\toolbutton.py
def __getitem__(self, item: str) -> QtWidgets.QAction:
    menu = self.menu()
    return menu[item]

for_menu(menu: QtWidgets.QMenu, icon: datatypes.IconType = None) classmethod

Source code in prettyqt\widgets\toolbutton.py
@classmethod
def for_menu(cls, menu: QtWidgets.QMenu, icon: datatypes.IconType = None):
    btn = cls()
    btn.setMenu(menu)
    # btn.set_title(menu.title())
    btn.set_popup_mode("instant")
    btn.set_icon(icon)
    return btn

get_arrow_type() -> constants.ArrowTypeStr

Return arrow type.

Returns:

Type Description
constants.ArrowTypeStr

arrow type

Source code in prettyqt\widgets\toolbutton.py
def get_arrow_type(self) -> constants.ArrowTypeStr:
    """Return arrow type.

    Returns:
        arrow type
    """
    return constants.ARROW_TYPE.inverse[self.arrowType()]

get_popup_mode() -> PopupModeStr

Return popup mode.

Returns:

Type Description
PopupModeStr

popup mode

Source code in prettyqt\widgets\toolbutton.py
def get_popup_mode(self) -> PopupModeStr:
    """Return popup mode.

    Returns:
        popup mode
    """
    return POPUP_MODE.inverse[self.popupMode()]

get_style() -> constants.ToolButtonStyleStr

Return toolbutton style.

Returns:

Type Description
constants.ToolButtonStyleStr

toolbutton style

Source code in prettyqt\widgets\toolbutton.py
def get_style(self) -> constants.ToolButtonStyleStr:
    """Return toolbutton style.

    Returns:
        toolbutton style
    """
    return constants.TOOLBUTTON_STYLE.inverse[self.toolButtonStyle()]

set_arrow_type(mode: constants.ArrowTypeStr)

Set the arrow type of the toolbutton.

Parameters:

Name Type Description Default
mode constants.ArrowTypeStr

arrow type to use

required

Raises:

Type Description
InvalidParamError

invalid arrow type

Source code in prettyqt\widgets\toolbutton.py
def set_arrow_type(self, mode: constants.ArrowTypeStr):
    """Set the arrow type of the toolbutton.

    Args:
        mode: arrow type to use

    Raises:
        InvalidParamError: invalid arrow type
    """
    if mode not in constants.ARROW_TYPE:
        raise InvalidParamError(mode, constants.ARROW_TYPE)
    self.setArrowType(constants.ARROW_TYPE[mode])

set_default_action(action)

Source code in prettyqt\widgets\toolbutton.py
def set_default_action(self, action):
    self.setDefaultAction(action)

set_popup_mode(mode: PopupModeStr)

Set the popup mode of the toolbutton.

Parameters:

Name Type Description Default
mode PopupModeStr

popup mode to use

required

Raises:

Type Description
InvalidParamError

invalid popup mode

Source code in prettyqt\widgets\toolbutton.py
def set_popup_mode(self, mode: PopupModeStr):
    """Set the popup mode of the toolbutton.

    Args:
        mode: popup mode to use

    Raises:
        InvalidParamError: invalid popup mode
    """
    if mode not in POPUP_MODE:
        raise InvalidParamError(mode, POPUP_MODE)
    self.setPopupMode(POPUP_MODE[mode])

set_style(style: constants.ToolButtonStyleStr)

Set the toolbutton style.

Parameters:

Name Type Description Default
style constants.ToolButtonStyleStr

style to use

required

Raises:

Type Description
InvalidParamError

invalid style

Source code in prettyqt\widgets\toolbutton.py
def set_style(self, style: constants.ToolButtonStyleStr):
    """Set the toolbutton style.

    Args:
        style: style to use

    Raises:
        InvalidParamError: invalid style
    """
    if style not in constants.TOOLBUTTON_STYLE:
        raise InvalidParamError(style, constants.TOOLBUTTON_STYLE)
    self.setToolButtonStyle(constants.TOOLBUTTON_STYLE[style])

ToolTip

Bases: QtWidgets.QToolTip

Source code in prettyqt\widgets\tooltip.py
class ToolTip(QtWidgets.QToolTip):
    @classmethod
    def show_text(
        cls,
        position: datatypes.PointType | None = None,
        text: str = "",
        linebreak_px: int = 400,
    ):
        if position is None:
            position = QtGui.QCursor.pos()
        elif isinstance(position, tuple):
            position = QtCore.QPoint(*position)
        cls.showText(position, f'<div style="max-width: {linebreak_px}px">{text}</div>')

show_text(position: datatypes.PointType | None = None, text: str = '', linebreak_px: int = 400) classmethod

Source code in prettyqt\widgets\tooltip.py
@classmethod
def show_text(
    cls,
    position: datatypes.PointType | None = None,
    text: str = "",
    linebreak_px: int = 400,
):
    if position is None:
        position = QtGui.QCursor.pos()
    elif isinstance(position, tuple):
        position = QtCore.QPoint(*position)
    cls.showText(position, f'<div style="max-width: {linebreak_px}px">{text}</div>')

TreeView

Bases: TreeViewMixin, QtWidgets.QTreeView

Source code in prettyqt\widgets\treeview.py
class TreeView(TreeViewMixin, QtWidgets.QTreeView):
    pass

TreeViewMixin

Bases: widgets.AbstractItemViewMixin

Source code in prettyqt\widgets\treeview.py
class TreeViewMixin(widgets.AbstractItemViewMixin):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        class_name = type(self).__name__
        self.set_id(class_name)
        # visual settings
        self.setAnimated(True)
        self.setRootIsDecorated(False)
        self.setAllColumnsShowFocus(True)
        self.setUniformRowHeights(True)
        self.setAlternatingRowColors(True)
        self.setWordWrap(False)

        # misc
        self.h_header = widgets.HeaderView("horizontal", parent=self)
        self.set_selection_mode("extended")

    def serialize_fields(self):
        return dict(
            all_columns_show_focus=self.allColumnsShowFocus(),
            animated=self.isAnimated(),
            auto_expand_delay=self.autoExpandDelay(),
            expands_on_double_click=self.expandsOnDoubleClick(),
            header_hidden=self.isHeaderHidden(),
            indentation=self.indentation(),
            items_expandable=self.itemsExpandable(),
            root_is_decorated=self.rootIsDecorated(),
            sorting_enabled=self.isSortingEnabled(),
            uniform_row_heights=self.uniformRowHeights(),
            word_wrap=self.wordWrap(),
        )

    @property
    def h_header(self):
        return self.header()

    @h_header.setter
    def h_header(self, header):
        self.setHeader(header)

    def expand_all(self):
        self.expandAll()

    def set_indentation(self, indentation: int):
        self.setIndentation(indentation)

    def setup_list_style(self):
        self.setSelectionBehavior(self.SelectionBehavior.SelectRows)
        self.h_header.setStretchLastSection(True)

    def adapt_sizes(self):
        model = self.model()
        if model is not None and (model.rowCount() * model.columnCount()) < 1000:
            self.h_header.resizeSections(self.h_header.ResizeMode.ResizeToContents)
        else:
            self.h_header.resize_sections("interactive")

    def sort_by_column(self, column: int | None, ascending: bool = True):
        column = -1 if column is None else column
        order = constants.ASCENDING if ascending else constants.DESCENDING
        self.sortByColumn(column, order)

h_header writable property

__init__(*args, **kwargs)

Source code in prettyqt\widgets\treeview.py
def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    class_name = type(self).__name__
    self.set_id(class_name)
    # visual settings
    self.setAnimated(True)
    self.setRootIsDecorated(False)
    self.setAllColumnsShowFocus(True)
    self.setUniformRowHeights(True)
    self.setAlternatingRowColors(True)
    self.setWordWrap(False)

    # misc
    self.h_header = widgets.HeaderView("horizontal", parent=self)
    self.set_selection_mode("extended")

adapt_sizes()

Source code in prettyqt\widgets\treeview.py
def adapt_sizes(self):
    model = self.model()
    if model is not None and (model.rowCount() * model.columnCount()) < 1000:
        self.h_header.resizeSections(self.h_header.ResizeMode.ResizeToContents)
    else:
        self.h_header.resize_sections("interactive")

expand_all()

Source code in prettyqt\widgets\treeview.py
def expand_all(self):
    self.expandAll()

serialize_fields()

Source code in prettyqt\widgets\treeview.py
def serialize_fields(self):
    return dict(
        all_columns_show_focus=self.allColumnsShowFocus(),
        animated=self.isAnimated(),
        auto_expand_delay=self.autoExpandDelay(),
        expands_on_double_click=self.expandsOnDoubleClick(),
        header_hidden=self.isHeaderHidden(),
        indentation=self.indentation(),
        items_expandable=self.itemsExpandable(),
        root_is_decorated=self.rootIsDecorated(),
        sorting_enabled=self.isSortingEnabled(),
        uniform_row_heights=self.uniformRowHeights(),
        word_wrap=self.wordWrap(),
    )

set_indentation(indentation: int)

Source code in prettyqt\widgets\treeview.py
def set_indentation(self, indentation: int):
    self.setIndentation(indentation)

setup_list_style()

Source code in prettyqt\widgets\treeview.py
def setup_list_style(self):
    self.setSelectionBehavior(self.SelectionBehavior.SelectRows)
    self.h_header.setStretchLastSection(True)

sort_by_column(column: int | None, ascending: bool = True)

Source code in prettyqt\widgets\treeview.py
def sort_by_column(self, column: int | None, ascending: bool = True):
    column = -1 if column is None else column
    order = constants.ASCENDING if ascending else constants.DESCENDING
    self.sortByColumn(column, order)

TreeWidget

Bases: TreeWidgetMixin, QtWidgets.QTreeWidget

Source code in prettyqt\widgets\treewidget.py
class TreeWidget(TreeWidgetMixin, QtWidgets.QTreeWidget):
    pass

TreeWidgetItem

Bases: serializemixin.SerializeMixin, QtWidgets.QTreeWidgetItem

Source code in prettyqt\widgets\treewidgetitem.py
class TreeWidgetItem(serializemixin.SerializeMixin, QtWidgets.QTreeWidgetItem):
    def __repr__(self):
        return get_repr(self)

    def serialize_fields(self):
        data = [
            self.data(i, constants.USER_ROLE)  # type: ignore
            for i in range(self.columnCount())
        ]
        return dict(
            text=[self.text(i) for i in range(self.columnCount())],
            tool_tip=[self.toolTip(i) for i in range(self.columnCount())],
            status_tip=[self.statusTip(i) for i in range(self.columnCount())],
            checkstate=[self.get_checkstate(i) for i in range(self.columnCount())],
            icon=[self.get_icon(i) for i in range(self.columnCount())],
            data=data,
        )

    def __iter__(self) -> Iterator[QtWidgets.QTreeWidgetItem]:
        return iter(self.child(i) for i in range(self.childCount()))

    def __len__(self):
        return self.childCount()

    def __getitem__(self, index: int) -> QtWidgets.QTreeWidgetItem:
        item = self.child(index)
        if item is None:
            raise KeyError(index)
        return item

    def __delitem__(self, index: int):
        self.takeChild(index)

    def __add__(self, other: QtWidgets.QTreeWidgetItem) -> TreeWidgetItem:
        self.addChild(other)
        return self

    def set_size_hint(self, hint: datatypes.SizeType, column: int = 0):
        if isinstance(hint, tuple):
            hint = QtCore.QSize(*hint)
        self.setSizeHint(column, hint)

    def sort_children(self, column: int, descending: bool = False):
        order = constants.DESCENDING if descending else constants.ASCENDING
        self.sortChildren(column, order)

    def set_icon(self, icon: datatypes.IconType, column: int = 0):
        """Set the icon for the action.

        Args:
            icon: icon to use
            column: column
        """
        icon = iconprovider.get_icon(icon)
        self.setIcon(column, icon)

    def get_background(self, column: int = 0) -> gui.Brush:
        return gui.Brush(self.background(column))

    def get_foreground(self, column: int = 0) -> gui.Brush:
        return gui.Brush(self.foreground(column))

    def get_font(self, column: int = 0) -> gui.Font:
        return gui.Font(self.font(column))

    def get_icon(self, column: int = 0) -> gui.Icon | None:
        icon = self.icon(column)
        return None if icon.isNull() else gui.Icon(icon)

    def set_checkstate(self, state: constants.StateStr, column: int = 0):
        """Set checkstate of the checkbox.

        Args:
            state: checkstate to use
            column: column

        Raises:
            InvalidParamError: invalid checkstate
        """
        if state not in constants.STATE:
            raise InvalidParamError(state, constants.STATE)
        self.setCheckState(column, constants.STATE[state])

    def get_checkstate(self, column: int = 0) -> constants.StateStr:
        """Return checkstate.

        Args:
            column: column

        Returns:
            checkstate
        """
        return constants.STATE.inverse[self.checkState(column)]

    def set_child_indicator_policy(self, policy: ChildIndicatorPolicyStr):
        """Set the child indicator policy.

        Args:
            policy: child indicator policy

        Raises:
            InvalidParamError: policy does not exist
        """
        if policy not in CHILD_INDICATOR_POLICY:
            raise InvalidParamError(policy, CHILD_INDICATOR_POLICY)
        self.setChildIndicatorPolicy(CHILD_INDICATOR_POLICY[policy])

    def get_child_indicator_policy(self) -> ChildIndicatorPolicyStr:
        """Return current child indicator policy.

        Returns:
            child indicator policy
        """
        return CHILD_INDICATOR_POLICY.inverse[self.childIndicatorPolicy()]

__add__(other: QtWidgets.QTreeWidgetItem) -> TreeWidgetItem

Source code in prettyqt\widgets\treewidgetitem.py
def __add__(self, other: QtWidgets.QTreeWidgetItem) -> TreeWidgetItem:
    self.addChild(other)
    return self

__delitem__(index: int)

Source code in prettyqt\widgets\treewidgetitem.py
def __delitem__(self, index: int):
    self.takeChild(index)

__getitem__(index: int) -> QtWidgets.QTreeWidgetItem

Source code in prettyqt\widgets\treewidgetitem.py
def __getitem__(self, index: int) -> QtWidgets.QTreeWidgetItem:
    item = self.child(index)
    if item is None:
        raise KeyError(index)
    return item

__iter__() -> Iterator[QtWidgets.QTreeWidgetItem]

Source code in prettyqt\widgets\treewidgetitem.py
def __iter__(self) -> Iterator[QtWidgets.QTreeWidgetItem]:
    return iter(self.child(i) for i in range(self.childCount()))

__len__()

Source code in prettyqt\widgets\treewidgetitem.py
def __len__(self):
    return self.childCount()

__repr__()

Source code in prettyqt\widgets\treewidgetitem.py
def __repr__(self):
    return get_repr(self)

get_background(column: int = 0) -> gui.Brush

Source code in prettyqt\widgets\treewidgetitem.py
def get_background(self, column: int = 0) -> gui.Brush:
    return gui.Brush(self.background(column))

get_checkstate(column: int = 0) -> constants.StateStr

Return checkstate.

Parameters:

Name Type Description Default
column int

column

0

Returns:

Type Description
constants.StateStr

checkstate

Source code in prettyqt\widgets\treewidgetitem.py
def get_checkstate(self, column: int = 0) -> constants.StateStr:
    """Return checkstate.

    Args:
        column: column

    Returns:
        checkstate
    """
    return constants.STATE.inverse[self.checkState(column)]

get_child_indicator_policy() -> ChildIndicatorPolicyStr

Return current child indicator policy.

Returns:

Type Description
ChildIndicatorPolicyStr

child indicator policy

Source code in prettyqt\widgets\treewidgetitem.py
def get_child_indicator_policy(self) -> ChildIndicatorPolicyStr:
    """Return current child indicator policy.

    Returns:
        child indicator policy
    """
    return CHILD_INDICATOR_POLICY.inverse[self.childIndicatorPolicy()]

get_font(column: int = 0) -> gui.Font

Source code in prettyqt\widgets\treewidgetitem.py
def get_font(self, column: int = 0) -> gui.Font:
    return gui.Font(self.font(column))

get_foreground(column: int = 0) -> gui.Brush

Source code in prettyqt\widgets\treewidgetitem.py
def get_foreground(self, column: int = 0) -> gui.Brush:
    return gui.Brush(self.foreground(column))

get_icon(column: int = 0) -> gui.Icon | None

Source code in prettyqt\widgets\treewidgetitem.py
def get_icon(self, column: int = 0) -> gui.Icon | None:
    icon = self.icon(column)
    return None if icon.isNull() else gui.Icon(icon)

serialize_fields()

Source code in prettyqt\widgets\treewidgetitem.py
def serialize_fields(self):
    data = [
        self.data(i, constants.USER_ROLE)  # type: ignore
        for i in range(self.columnCount())
    ]
    return dict(
        text=[self.text(i) for i in range(self.columnCount())],
        tool_tip=[self.toolTip(i) for i in range(self.columnCount())],
        status_tip=[self.statusTip(i) for i in range(self.columnCount())],
        checkstate=[self.get_checkstate(i) for i in range(self.columnCount())],
        icon=[self.get_icon(i) for i in range(self.columnCount())],
        data=data,
    )

set_checkstate(state: constants.StateStr, column: int = 0)

Set checkstate of the checkbox.

Parameters:

Name Type Description Default
state constants.StateStr

checkstate to use

required
column int

column

0

Raises:

Type Description
InvalidParamError

invalid checkstate

Source code in prettyqt\widgets\treewidgetitem.py
def set_checkstate(self, state: constants.StateStr, column: int = 0):
    """Set checkstate of the checkbox.

    Args:
        state: checkstate to use
        column: column

    Raises:
        InvalidParamError: invalid checkstate
    """
    if state not in constants.STATE:
        raise InvalidParamError(state, constants.STATE)
    self.setCheckState(column, constants.STATE[state])

set_child_indicator_policy(policy: ChildIndicatorPolicyStr)

Set the child indicator policy.

Parameters:

Name Type Description Default
policy ChildIndicatorPolicyStr

child indicator policy

required

Raises:

Type Description
InvalidParamError

policy does not exist

Source code in prettyqt\widgets\treewidgetitem.py
def set_child_indicator_policy(self, policy: ChildIndicatorPolicyStr):
    """Set the child indicator policy.

    Args:
        policy: child indicator policy

    Raises:
        InvalidParamError: policy does not exist
    """
    if policy not in CHILD_INDICATOR_POLICY:
        raise InvalidParamError(policy, CHILD_INDICATOR_POLICY)
    self.setChildIndicatorPolicy(CHILD_INDICATOR_POLICY[policy])

set_icon(icon: datatypes.IconType, column: int = 0)

Set the icon for the action.

Parameters:

Name Type Description Default
icon datatypes.IconType

icon to use

required
column int

column

0
Source code in prettyqt\widgets\treewidgetitem.py
def set_icon(self, icon: datatypes.IconType, column: int = 0):
    """Set the icon for the action.

    Args:
        icon: icon to use
        column: column
    """
    icon = iconprovider.get_icon(icon)
    self.setIcon(column, icon)

set_size_hint(hint: datatypes.SizeType, column: int = 0)

Source code in prettyqt\widgets\treewidgetitem.py
def set_size_hint(self, hint: datatypes.SizeType, column: int = 0):
    if isinstance(hint, tuple):
        hint = QtCore.QSize(*hint)
    self.setSizeHint(column, hint)

sort_children(column: int, descending: bool = False)

Source code in prettyqt\widgets\treewidgetitem.py
def sort_children(self, column: int, descending: bool = False):
    order = constants.DESCENDING if descending else constants.ASCENDING
    self.sortChildren(column, order)

TreeWidgetItemIterator

Bases: QtWidgets.QTreeWidgetItemIterator

Source code in prettyqt\widgets\treewidgetitemiterator.py
class TreeWidgetItemIterator(QtWidgets.QTreeWidgetItemIterator):
    def __init__(
        self,
        other: (
            QtWidgets.QTreeWidget
            | QtWidgets.QTreeWidgetItem
            | QtWidgets.QTreeWidgetItemIterator
        ),
        flags: QtWidgets.QTreeWidgetItemIterator.IteratorFlag | None = None,
        hidden: bool | None = None,
        selected: bool | None = None,
        selectable: bool | None = None,
        draggable: bool | None = None,
        droppable: bool | None = None,
        has_children: bool | None = None,
        checked: bool | None = None,
        enabled: bool | None = None,
        editable: bool | None = None,
        user_flag: bool = False,
    ):
        if isinstance(other, QtWidgets.QTreeWidgetItemIterator):
            super().__init__(other)
        else:
            if flags is None:
                flags = mod.IteratorFlag.All  # type: ignore
            if hidden is True:
                flags |= mod.IteratorFlag.Hidden  # type: ignore
            elif hidden is False:
                flags |= mod.IteratorFlag.NotHidden  # type: ignore
            if selected is True:
                flags |= mod.IteratorFlag.Selected  # type: ignore
            elif selected is False:
                flags |= mod.IteratorFlag.Unselected  # type: ignore
            if selectable is True:
                flags |= mod.IteratorFlag.Selectable  # type: ignore
            elif selectable is False:
                flags |= mod.IteratorFlag.NotSelectable  # type: ignore
            if draggable is True:
                flags |= mod.IteratorFlag.DragEnabled  # type: ignore
            elif draggable is False:
                flags |= mod.IteratorFlag.DragDisabled  # type: ignore
            if droppable is True:
                flags |= mod.IteratorFlag.DropEnabled  # type: ignore
            elif droppable is False:
                flags |= mod.IteratorFlag.DropDisabled  # type: ignore
            if has_children is True:
                flags |= mod.IteratorFlag.HasChildren  # type: ignore
            elif has_children is False:
                flags |= mod.IteratorFlag.NoChildren  # type: ignore
            if checked is True:
                flags |= mod.IteratorFlag.Checked  # type: ignore
            elif checked is False:
                flags |= mod.IteratorFlag.NotChecked  # type: ignore
            if enabled is True:
                flags |= mod.IteratorFlag.Enabled  # type: ignore
            elif enabled is False:
                flags |= mod.IteratorFlag.Disabled  # type: ignore
            if editable is True:
                flags |= mod.IteratorFlag.Editable  # type: ignore
            elif editable is False:
                flags |= mod.IteratorFlag.NotEditable  # type: ignore
            if user_flag:
                flags |= mod.IteratorFlag.UserFlag  # type: ignore
            super().__init__(other, flags)  # type: ignore

__init__(other: QtWidgets.QTreeWidget | QtWidgets.QTreeWidgetItem | QtWidgets.QTreeWidgetItemIterator, flags: QtWidgets.QTreeWidgetItemIterator.IteratorFlag | None = None, hidden: bool | None = None, selected: bool | None = None, selectable: bool | None = None, draggable: bool | None = None, droppable: bool | None = None, has_children: bool | None = None, checked: bool | None = None, enabled: bool | None = None, editable: bool | None = None, user_flag: bool = False)

Source code in prettyqt\widgets\treewidgetitemiterator.py
def __init__(
    self,
    other: (
        QtWidgets.QTreeWidget
        | QtWidgets.QTreeWidgetItem
        | QtWidgets.QTreeWidgetItemIterator
    ),
    flags: QtWidgets.QTreeWidgetItemIterator.IteratorFlag | None = None,
    hidden: bool | None = None,
    selected: bool | None = None,
    selectable: bool | None = None,
    draggable: bool | None = None,
    droppable: bool | None = None,
    has_children: bool | None = None,
    checked: bool | None = None,
    enabled: bool | None = None,
    editable: bool | None = None,
    user_flag: bool = False,
):
    if isinstance(other, QtWidgets.QTreeWidgetItemIterator):
        super().__init__(other)
    else:
        if flags is None:
            flags = mod.IteratorFlag.All  # type: ignore
        if hidden is True:
            flags |= mod.IteratorFlag.Hidden  # type: ignore
        elif hidden is False:
            flags |= mod.IteratorFlag.NotHidden  # type: ignore
        if selected is True:
            flags |= mod.IteratorFlag.Selected  # type: ignore
        elif selected is False:
            flags |= mod.IteratorFlag.Unselected  # type: ignore
        if selectable is True:
            flags |= mod.IteratorFlag.Selectable  # type: ignore
        elif selectable is False:
            flags |= mod.IteratorFlag.NotSelectable  # type: ignore
        if draggable is True:
            flags |= mod.IteratorFlag.DragEnabled  # type: ignore
        elif draggable is False:
            flags |= mod.IteratorFlag.DragDisabled  # type: ignore
        if droppable is True:
            flags |= mod.IteratorFlag.DropEnabled  # type: ignore
        elif droppable is False:
            flags |= mod.IteratorFlag.DropDisabled  # type: ignore
        if has_children is True:
            flags |= mod.IteratorFlag.HasChildren  # type: ignore
        elif has_children is False:
            flags |= mod.IteratorFlag.NoChildren  # type: ignore
        if checked is True:
            flags |= mod.IteratorFlag.Checked  # type: ignore
        elif checked is False:
            flags |= mod.IteratorFlag.NotChecked  # type: ignore
        if enabled is True:
            flags |= mod.IteratorFlag.Enabled  # type: ignore
        elif enabled is False:
            flags |= mod.IteratorFlag.Disabled  # type: ignore
        if editable is True:
            flags |= mod.IteratorFlag.Editable  # type: ignore
        elif editable is False:
            flags |= mod.IteratorFlag.NotEditable  # type: ignore
        if user_flag:
            flags |= mod.IteratorFlag.UserFlag  # type: ignore
        super().__init__(other, flags)  # type: ignore

UndoView

Bases: widgets.ListViewMixin, QtWidgets.QUndoView

Source code in prettyqt\widgets\undoview.py
class UndoView(widgets.ListViewMixin, QtWidgets.QUndoView):
    def __getitem__(self, index: int) -> QtGui.QUndoCommand:
        return self.stack().command(index)

    def set_clean_icon(self, icon: datatypes.IconType):
        """Set the icon for the clean button.

        Args:
            icon: icon to use
        """
        icon = iconprovider.get_icon(icon)
        self.setCleanIcon(icon)

    def set_value(self, value: QtGui.QUndoGroup | QtGui.QUndoStack):
        if isinstance(value, QtGui.QUndoGroup):
            self.setGroup(value)
        else:
            self.setStack(value)

__getitem__(index: int) -> QtGui.QUndoCommand

Source code in prettyqt\widgets\undoview.py
def __getitem__(self, index: int) -> QtGui.QUndoCommand:
    return self.stack().command(index)

set_clean_icon(icon: datatypes.IconType)

Set the icon for the clean button.

Parameters:

Name Type Description Default
icon datatypes.IconType

icon to use

required
Source code in prettyqt\widgets\undoview.py
def set_clean_icon(self, icon: datatypes.IconType):
    """Set the icon for the clean button.

    Args:
        icon: icon to use
    """
    icon = iconprovider.get_icon(icon)
    self.setCleanIcon(icon)

set_value(value: QtGui.QUndoGroup | QtGui.QUndoStack)

Source code in prettyqt\widgets\undoview.py
def set_value(self, value: QtGui.QUndoGroup | QtGui.QUndoStack):
    if isinstance(value, QtGui.QUndoGroup):
        self.setGroup(value)
    else:
        self.setStack(value)

WhatsThis

Bases: QtWidgets.QWhatsThis

Source code in prettyqt\widgets\whatsthis.py
class WhatsThis(QtWidgets.QWhatsThis):
    @classmethod
    @contextlib.contextmanager
    def enter_mode(cls):
        cls.enterWhatsThisMode()
        yield cls
        cls.leaveWhatsThisMode()

enter_mode() classmethod

Source code in prettyqt\widgets\whatsthis.py
@classmethod
@contextlib.contextmanager
def enter_mode(cls):
    cls.enterWhatsThisMode()
    yield cls
    cls.leaveWhatsThisMode()

Widget

Bases: WidgetMixin, prettyprinter.PrettyPrinter, QtWidgets.QWidget

Source code in prettyqt\widgets\widget.py
class Widget(WidgetMixin, prettyprinter.PrettyPrinter, QtWidgets.QWidget):
    pass

WidgetAction

Bases: widgets.ActionMixin, QtWidgets.QWidgetAction

Source code in prettyqt\widgets\widgetaction.py
class WidgetAction(widgets.ActionMixin, QtWidgets.QWidgetAction):
    def __init__(self, parent: QtCore.QObject | None = None):
        super().__init__(parent)  # type: ignore
        self._menu = None  # bc of PySide inheritance also defined here

__init__(parent: QtCore.QObject | None = None)

Source code in prettyqt\widgets\widgetaction.py
def __init__(self, parent: QtCore.QObject | None = None):
    super().__init__(parent)  # type: ignore
    self._menu = None  # bc of PySide inheritance also defined here

WidgetItem

Bases: widgets.LayoutItemMixin, QtWidgets.QWidgetItem

Source code in prettyqt\widgets\widgetitem.py
class WidgetItem(widgets.LayoutItemMixin, QtWidgets.QWidgetItem):
    pass

WidgetMixin

Bases: core.ObjectMixin

Source code in prettyqt\widgets\widget.py
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
class WidgetMixin(core.ObjectMixin):
    box: QtWidgets.QLayout

    def __repr__(self) -> str:
        return get_repr(self)

    def resize(self, *size) -> None:
        if isinstance(size[0], tuple):
            super().resize(*size[0])
        else:
            super().resize(*size)

    def toggle_fullscreen(self):
        """Toggle between fullscreen and regular size."""
        if self.isFullScreen():
            self.showNormal()
        else:
            self.showFullScreen()

    def toggle_maximized(self):
        """Toggle between maximized and regular size."""
        if self.isMaximized():
            self.showNormal()
        else:
            self.showMaximized()

    def raise_to_top(self):
        if sys.platform.startswith("win"):
            import win32con
            from win32gui import SetWindowPos

            # set to always-on-top and disable it again. that way windows stays in front
            flag = win32con.SWP_NOMOVE | win32con.SWP_NOSIZE | win32con.SWP_SHOWWINDOW
            win_id = self.winId()
            SetWindowPos(win_id, win32con.HWND_TOPMOST, 0, 0, 0, 0, flag)
            SetWindowPos(win_id, win32con.HWND_NOTOPMOST, 0, 0, 0, 0, flag)
        # state = (self.windowState() & ~Qt.WindowMinimized) | Qt.WindowActive
        # self.setWindowState(state)
        self.raise_()
        self.show()
        self.activateWindow()

    def set_icon(self, icon: datatypes.IconType) -> None:
        """Set the window icon.

        Args:
            icon: icon to use
        """
        icon = iconprovider.get_icon(icon, color=colors.WINDOW_ICON_COLOR)
        self.setWindowIcon(icon)

    def get_icon(self) -> gui.Icon | None:
        icon = self.windowIcon()
        return None if icon.isNull() else gui.Icon(icon)

    @functools.singledispatchmethod
    def set_min_size(self, size: QtCore.QSize | tuple[int | None, int | None]) -> None:
        if isinstance(size, tuple):
            x = 0 if size[0] is None else size[0]
            y = 0 if size[1] is None else size[1]
            self.setMinimumSize(x, y)
        else:
            self.setMinimumSize(size)

    @set_min_size.register
    def _(self, x: int, y: int | None):
        self.set_min_size((x, y))

    @set_min_size.register  # these can be merged when min py version is 3.11
    def _(self, x: None, y: int | None):
        self.set_min_size((x, y))

    @functools.singledispatchmethod
    def set_max_size(self, size: QtCore.QSize | tuple[int | None, int | None]) -> None:
        if isinstance(size, tuple):
            x = QWIDGETSIZE_MAX if size[0] is None else size[0]
            y = QWIDGETSIZE_MAX if size[1] is None else size[1]
            self.setMaximumSize(x, y)
        else:
            self.setMaximumSize(size)

    @set_max_size.register
    def _(self, x: int, y: int | None):
        self.set_max_size((x, y))

    @set_max_size.register  # these can be merged when min py version is 3.11
    def _(self, x: None, y: int | None):
        self.set_max_size((x, y))

    def set_min_width(self, width: int | None) -> None:
        if width is None:
            width = 0
        self.setMinimumWidth(width)

    def set_max_width(self, width: int | None) -> None:
        if width is None:
            width = QWIDGETSIZE_MAX
        self.setMaximumWidth(width)

    def set_min_height(self, height: int | None) -> None:
        if height is None:
            height = 0
        self.setMinimumHeight(height)

    def set_max_height(self, height: int | None) -> None:
        if height is None:
            height = QWIDGETSIZE_MAX
        self.setMaximumHeight(height)

    def set_enabled(self, enabled: bool = True) -> None:
        self.setEnabled(enabled)

    def set_disabled(self) -> None:
        self.setEnabled(False)

    def set_title(self, title: str) -> None:
        self.setWindowTitle(title)

    def get_title(self) -> str:
        return self.windowTitle()

    def set_tooltip(
        self,
        tooltip: str | datatypes.PathType,
        size: datatypes.SizeType | None = None,
    ):
        if isinstance(tooltip, os.PathLike):
            path = os.fspath(tooltip)
            if size is None:
                tooltip = f"<img src={path!r}>"
            else:
                if isinstance(size, QtCore.QSize):
                    size = (size.width(), size.height())
                tooltip = f'<img src={path!r} width="{size[0]}" height="{size[1]}">'
        self.setToolTip(tooltip)

    def set_font(
        self,
        font_name: str | None = None,
        font_size: int | None = None,
        weight: int | None = None,
        italic: bool = False,
    ) -> gui.Font:
        if font_size is None:
            font_size = -1
        if weight is None:
            weight = -1
        if font_name is None:
            font_name = self.font().family()
        font = gui.Font(font_name, font_size, weight, italic)
        self.setFont(font)
        return font

    def get_font(self) -> gui.Font:
        return gui.Font(self.font())

    def get_foreground_role(self) -> gui.palette.RoleStr:
        return gui.palette.ROLE.inverse[self.foregroundRole()]

    def set_foreground_role(self, role: gui.palette.RoleStr):
        if role not in gui.palette.ROLE:
            raise InvalidParamError(role, gui.palette.ROLE)
        self.setForegroundRole(gui.palette.ROLE[role])

    def get_background_role(self) -> gui.palette.RoleStr:
        return gui.palette.ROLE.inverse[self.backgroundRole()]

    def set_background_role(self, role: gui.palette.RoleStr):
        if role not in gui.palette.ROLE:
            raise InvalidParamError(role, gui.palette.ROLE)
        self.setBackgroundRole(gui.palette.ROLE[role])

    def set_window_flags(self, *flags: constants.WindowFlagStr, append: bool = False):
        for flag in flags:
            if flag not in constants.WINDOW_FLAGS:
                raise InvalidParamError(flag, constants.WINDOW_FLAGS)
        result = helpers.merge_flags(flags, constants.WINDOW_FLAGS)
        if append:
            result = result | self.windowFlags()
        self.setWindowFlags(result)

    def set_flags(
        self,
        minimize: bool | None = None,
        maximize: bool | None = None,
        close: bool | None = None,
        stay_on_top: bool | None = None,
        frameless: bool | None = None,
        window: bool | None = None,
        dialog: bool | None = None,
        tooltip: bool | None = None,
        tool: bool | None = None,
        customize: bool | None = None,
        window_title: bool | None = None,
    ) -> None:
        flags = {
            minimize: QtCore.Qt.WindowType.WindowMinimizeButtonHint,
            maximize: QtCore.Qt.WindowType.WindowMaximizeButtonHint,
            close: QtCore.Qt.WindowType.WindowCloseButtonHint,
            stay_on_top: QtCore.Qt.WindowType.WindowStaysOnTopHint,
            frameless: QtCore.Qt.WindowType.FramelessWindowHint,
            window: QtCore.Qt.WindowType.Window,
            dialog: QtCore.Qt.WindowType.Dialog,
            tooltip: QtCore.Qt.WindowType.ToolTip,
            tool: QtCore.Qt.WindowType.Tool,
            customize: QtCore.Qt.WindowType.CustomizeWindowHint,
            window_title: QtCore.Qt.WindowType.WindowTitleHint,
        }
        for k, v in flags.items():
            if k is not None:
                self.setWindowFlag(v, k)

    def set_attribute(
        self, attribute: constants.WidgetAttributeStr, state: bool = True
    ) -> None:
        if attribute not in constants.WIDGET_ATTRIBUTE:
            raise InvalidParamError(attribute, constants.WIDGET_ATTRIBUTE)
        self.setAttribute(constants.WIDGET_ATTRIBUTE[attribute], state)

    def set_attributes(self, **kwargs: bool) -> None:
        for attr, state in kwargs.items():
            if attr not in constants.WIDGET_ATTRIBUTE:
                raise InvalidParamError(attr, constants.WIDGET_ATTRIBUTE)
            self.setAttribute(constants.WIDGET_ATTRIBUTE[attr], state)  # type: ignore

    def set_modality(self, modality: constants.ModalityStr) -> None:
        """Set modality for the dialog.

        Args:
            modality: modality for the main window

        Raises:
            InvalidParamError: modality type does not exist
        """
        if modality not in constants.MODALITY:
            raise InvalidParamError(modality, constants.MODALITY)
        self.setWindowModality(constants.MODALITY[modality])

    def get_modality(self) -> constants.ModalityStr:
        """Get the current modality modes as a string.

        Returns:
            modality mode
        """
        return constants.MODALITY.inverse[self.windowModality()]

    def set_size_policy(
        self,
        horizontal: widgets.sizepolicy.SizePolicyStr | None = None,
        vertical: widgets.sizepolicy.SizePolicyStr | None = None,
    ) -> None:
        """Set the sizes policy.

        Args:
            horizontal: horizontal size policy
            vertical: vertical size policy
        """
        sp = self.get_size_policy()
        if horizontal is not None:
            sp.set_horizontal_policy(horizontal)
        if vertical is not None:
            sp.set_vertical_policy(vertical)
        self.setSizePolicy(sp)

    def get_size_policy(self) -> widgets.SizePolicy:
        qpol = self.sizePolicy()
        if isinstance(qpol, widgets.SizePolicy):
            return qpol
        return widgets.SizePolicy.clone(qpol)

    def get_palette(self) -> gui.Palette:
        return gui.Palette(self.palette())

    def set_background_color(self, color: datatypes.ColorType) -> None:
        col_str = "" if color is None else colors.get_color(color).name()
        with self.edit_stylesheet() as ss:
            ss.backgroundColor.setValue(col_str)

    @contextlib.contextmanager
    def grab_mouse_events(
        self, cursor_shape: constants.CursorShapeStr | None = None
    ) -> Iterator[None]:
        if cursor_shape is not None:
            self.grabMouse(constants.CURSOR_SHAPE[cursor_shape])
        else:
            self.grabMouse()
        yield None
        self.releaseMouse()

    @contextlib.contextmanager
    def grab_keyboard_events(self) -> Iterator[None]:
        self.grabKeyboard()
        yield None
        self.releaseKeyboard()

    @contextlib.contextmanager
    def updates_off(self) -> Iterator[None]:
        updates = self.updatesEnabled()
        self.setUpdatesEnabled(False)
        yield None
        self.setUpdatesEnabled(updates)

    @contextlib.contextmanager
    def edit_stylesheet(self) -> Iterator[qstylizer.style.StyleSheet]:
        ss = self.get_stylesheet()
        yield ss
        self.set_stylesheet(ss)

    def set_stylesheet(
        self, ss: None | str | qstylizer.style.StyleSheet | datatypes.PathType
    ):
        match ss:
            case None:
                ss = ""
            case os.PathLike():
                ss = pathlib.Path(ss).read_text()
            case qstylizer.style.StyleSheet():
                ss = str(ss)
        self.setStyleSheet(ss)

    def get_stylesheet(self) -> qstylizer.style.StyleSheet:
        try:
            return qstylizer.parser.parse(self.styleSheet())
        except ValueError:
            return qstylizer.style.StyleSheet()

    @contextlib.contextmanager
    def edit_palette(self) -> Iterator[gui.Palette]:
        palette = gui.Palette(self.palette())
        yield palette
        self.setPalette(palette)

    @contextlib.contextmanager
    def edit_font(self) -> Iterator[gui.Font]:
        font = gui.Font(self.font())
        yield font
        self.setFont(font)

    @deprecated(reason="This context manager is deprecated, use edit_font instead.")
    @contextlib.contextmanager
    def current_font(self) -> Iterator[gui.Font]:
        with self.edit_font() as font:
            yield font

    @deprecated(reason="This method is deprecated, use set_context_menu_policy instead.")
    def set_contextmenu_policy(self, policy: constants.ContextPolicyStr) -> None:
        return self.set_context_menu_policy(policy)

    def set_context_menu_policy(self, policy: constants.ContextPolicyStr) -> None:
        """Set contextmenu policy for given item view.

        Args:
            policy: contextmenu policy to use

        Raises:
            InvalidParamError: policy does not exist
        """
        if policy not in constants.CONTEXT_POLICY:
            raise InvalidParamError(policy, constants.CONTEXT_POLICY)
        self.setContextMenuPolicy(constants.CONTEXT_POLICY[policy])

    @deprecated(reason="This method is deprecated, use get_context_menu_policy instead.")
    def get_contextmenu_policy(self) -> constants.ContextPolicyStr:
        """Return current contextmenu policy.

        Returns:
            contextmenu policy
        """
        return self.get_context_menu_policy()

    def get_context_menu_policy(self) -> constants.ContextPolicyStr:
        """Return current contextmenu policy.

        Returns:
            contextmenu policy
        """
        return constants.CONTEXT_POLICY.inverse[self.contextMenuPolicy()]

    def set_window_state(self, policy: constants.WindowStateStr) -> None:
        """Set window state for given item view.

        Args:
            policy: window state to use

        Raises:
            InvalidParamError: policy does not exist
        """
        if policy not in constants.WINDOW_STATES:
            raise InvalidParamError(policy, constants.WINDOW_STATES)
        self.setWindowState(constants.WINDOW_STATES[policy])

    def get_window_state(self) -> constants.WindowStateStr:
        """Return current window state.

        Returns:
            window state
        """
        return constants.WINDOW_STATES.inverse[self.windowState()]

    def set_custom_menu(self, method: Callable) -> None:
        self.set_context_menu_policy("custom")
        self.customContextMenuRequested.connect(method)

    def set_layout(
        self,
        layout: LayoutStr | QtWidgets.QLayout | None,
        margin: int | None = None,
        spacing: int | None = None,
    ):
        if layout is None:
            return
        match layout:
            case "horizontal" | "vertical":
                self.box = widgets.BoxLayout(layout)
            case "grid":
                self.box = widgets.GridLayout()
            case "form":
                self.box = widgets.FormLayout()
            case "stacked":
                self.box = widgets.StackedLayout()
            case "flow":
                from prettyqt import custom_widgets

                self.box = custom_widgets.FlowLayout()
            case QtWidgets.QLayout():
                self.box = layout
            case _:
                raise ValueError("Invalid Layout")
        self.setLayout(self.box)
        if margin is not None:
            self.box.set_margin(margin)
        if spacing is not None:
            self.box.setSpacing(spacing)

    def center(self, screen: int = 0) -> None:
        qr = self.frameGeometry()
        cp = gui.GuiApplication.screens()[screen].geometry().center()
        qr.moveCenter(cp)
        self.move(qr.topLeft())

    def set_cursor(self, cursor: constants.CursorShapeStr | QtGui.QCursor) -> None:
        if isinstance(cursor, QtGui.QCursor):
            curs = cursor
        elif cursor in constants.CURSOR_SHAPE:
            curs = gui.Cursor(constants.CURSOR_SHAPE[cursor])
        else:
            raise InvalidParamError(cursor, constants.CURSOR_SHAPE)
        self.setCursor(curs)

    def set_focus_policy(self, policy: constants.FocusPolicyStr) -> None:
        """Set the way the widget accepts keyboard focus.

        Args:
            policy (str): Focus policy

        Raises:
            InvalidParamError: Description
        """
        if policy not in constants.FOCUS_POLICY:
            raise InvalidParamError(policy, constants.FOCUS_POLICY)
        self.setFocusPolicy(constants.FOCUS_POLICY[policy])

    def get_focus_policy(self) -> constants.FocusPolicyStr:
        """Return waay the widget accepts keyboard focus.

        Returns:
            str: Focus policy
        """
        return constants.FOCUS_POLICY.inverse[self.focusPolicy()]

    def set_font_size(self, size: int) -> None:
        font = self.font()
        font.setPointSize(size)
        self.setFont(font)

    @deprecated(reason="This method is deprecated, use get_font_metrics instead.")
    def font_metrics(self) -> gui.FontMetrics:
        return self.get_font_metrics()

    def get_font_metrics(self) -> gui.FontMetrics:
        return gui.FontMetrics(self.fontMetrics())

    def get_font_info(self) -> gui.FontInfo:
        return gui.FontInfo(self.fontInfo())

    def set_margin(self, margin: int) -> None:
        self.setContentsMargins(margin, margin, margin, margin)

    def raise_dock(self) -> bool:
        w = self.find_parent(QtWidgets.QDockWidget)
        if w is None:
            return False
        w.setVisible(True)
        w.raise_()
        return True

    def set_mask(
        self,
        area: datatypes.RectType | QtGui.QRegion | None,
        typ: gui.region.RegionTypeStr = "rectangle",
    ):
        match area:
            case None:
                self.clearMask()
                return
            case tuple():
                area = gui.Region(*area, gui.region.REGION_TYPE[typ])
            case QtCore.QRect():
                area = gui.Region(area, gui.region.REGION_TYPE[typ])
        self.setMask(area)

    def set_window_file_path(self, path: datatypes.PathType):
        self.setWindowFilePath(os.fspath(path))

    def get_window_file_path(self) -> pathlib.Path | None:
        path = self.windowFilePath()
        return pathlib.Path(path) if path else None

    def get_image(self) -> QtGui.QPixmap:
        image = self.grab()
        if gl_widget := self.find_child(QtWidgets.QOpenGLWidget):
            d = gl_widget.mapToGlobal(core.Point()) - self.mapToGlobal(core.Point())
            with gui.Painter(image) as painter:
                painter.set_composition_mode("source_atop")
                painter.drawImage(d, gl_widget.grabFramebuffer())
        return image

    def get_screen(self) -> gui.Screen | None:
        window = self.window().windowHandle()
        return None if window is None else gui.Screen(window.screen())

    def delete_children(self):
        """Delete all children of the specified QObject."""
        if hasattr(self, "clear"):
            return self.clear()
        layout = self.layout()
        while layout.count():
            item = layout.takeAt(0)
            if widget := item.widget():
                widget.deleteLater()
            else:
                self.delete_children(item.layout())

    def get_cursor(self) -> gui.Cursor:
        return gui.Cursor(self.cursor())

box: QtWidgets.QLayout class-attribute

_(x: None, y: int | None)

Source code in prettyqt\widgets\widget.py
@set_max_size.register  # these can be merged when min py version is 3.11
def _(self, x: None, y: int | None):
    self.set_max_size((x, y))

__repr__() -> str

Source code in prettyqt\widgets\widget.py
def __repr__(self) -> str:
    return get_repr(self)

center(screen: int = 0) -> None

Source code in prettyqt\widgets\widget.py
def center(self, screen: int = 0) -> None:
    qr = self.frameGeometry()
    cp = gui.GuiApplication.screens()[screen].geometry().center()
    qr.moveCenter(cp)
    self.move(qr.topLeft())

current_font() -> Iterator[gui.Font]

Source code in prettyqt\widgets\widget.py
@deprecated(reason="This context manager is deprecated, use edit_font instead.")
@contextlib.contextmanager
def current_font(self) -> Iterator[gui.Font]:
    with self.edit_font() as font:
        yield font

delete_children()

Delete all children of the specified QObject.

Source code in prettyqt\widgets\widget.py
def delete_children(self):
    """Delete all children of the specified QObject."""
    if hasattr(self, "clear"):
        return self.clear()
    layout = self.layout()
    while layout.count():
        item = layout.takeAt(0)
        if widget := item.widget():
            widget.deleteLater()
        else:
            self.delete_children(item.layout())

edit_font() -> Iterator[gui.Font]

Source code in prettyqt\widgets\widget.py
@contextlib.contextmanager
def edit_font(self) -> Iterator[gui.Font]:
    font = gui.Font(self.font())
    yield font
    self.setFont(font)

edit_palette() -> Iterator[gui.Palette]

Source code in prettyqt\widgets\widget.py
@contextlib.contextmanager
def edit_palette(self) -> Iterator[gui.Palette]:
    palette = gui.Palette(self.palette())
    yield palette
    self.setPalette(palette)

edit_stylesheet() -> Iterator[qstylizer.style.StyleSheet]

Source code in prettyqt\widgets\widget.py
@contextlib.contextmanager
def edit_stylesheet(self) -> Iterator[qstylizer.style.StyleSheet]:
    ss = self.get_stylesheet()
    yield ss
    self.set_stylesheet(ss)

font_metrics() -> gui.FontMetrics

Source code in prettyqt\widgets\widget.py
@deprecated(reason="This method is deprecated, use get_font_metrics instead.")
def font_metrics(self) -> gui.FontMetrics:
    return self.get_font_metrics()

get_background_role() -> gui.palette.RoleStr

Source code in prettyqt\widgets\widget.py
def get_background_role(self) -> gui.palette.RoleStr:
    return gui.palette.ROLE.inverse[self.backgroundRole()]

get_context_menu_policy() -> constants.ContextPolicyStr

Return current contextmenu policy.

Returns:

Type Description
constants.ContextPolicyStr

contextmenu policy

Source code in prettyqt\widgets\widget.py
def get_context_menu_policy(self) -> constants.ContextPolicyStr:
    """Return current contextmenu policy.

    Returns:
        contextmenu policy
    """
    return constants.CONTEXT_POLICY.inverse[self.contextMenuPolicy()]

get_contextmenu_policy() -> constants.ContextPolicyStr

Return current contextmenu policy.

Returns:

Type Description
constants.ContextPolicyStr

contextmenu policy

Source code in prettyqt\widgets\widget.py
@deprecated(reason="This method is deprecated, use get_context_menu_policy instead.")
def get_contextmenu_policy(self) -> constants.ContextPolicyStr:
    """Return current contextmenu policy.

    Returns:
        contextmenu policy
    """
    return self.get_context_menu_policy()

get_cursor() -> gui.Cursor

Source code in prettyqt\widgets\widget.py
def get_cursor(self) -> gui.Cursor:
    return gui.Cursor(self.cursor())

get_focus_policy() -> constants.FocusPolicyStr

Return waay the widget accepts keyboard focus.

Returns:

Name Type Description
str constants.FocusPolicyStr

Focus policy

Source code in prettyqt\widgets\widget.py
def get_focus_policy(self) -> constants.FocusPolicyStr:
    """Return waay the widget accepts keyboard focus.

    Returns:
        str: Focus policy
    """
    return constants.FOCUS_POLICY.inverse[self.focusPolicy()]

get_font() -> gui.Font

Source code in prettyqt\widgets\widget.py
def get_font(self) -> gui.Font:
    return gui.Font(self.font())

get_font_info() -> gui.FontInfo

Source code in prettyqt\widgets\widget.py
def get_font_info(self) -> gui.FontInfo:
    return gui.FontInfo(self.fontInfo())

get_font_metrics() -> gui.FontMetrics

Source code in prettyqt\widgets\widget.py
def get_font_metrics(self) -> gui.FontMetrics:
    return gui.FontMetrics(self.fontMetrics())

get_foreground_role() -> gui.palette.RoleStr

Source code in prettyqt\widgets\widget.py
def get_foreground_role(self) -> gui.palette.RoleStr:
    return gui.palette.ROLE.inverse[self.foregroundRole()]

get_icon() -> gui.Icon | None

Source code in prettyqt\widgets\widget.py
def get_icon(self) -> gui.Icon | None:
    icon = self.windowIcon()
    return None if icon.isNull() else gui.Icon(icon)

get_image() -> QtGui.QPixmap

Source code in prettyqt\widgets\widget.py
def get_image(self) -> QtGui.QPixmap:
    image = self.grab()
    if gl_widget := self.find_child(QtWidgets.QOpenGLWidget):
        d = gl_widget.mapToGlobal(core.Point()) - self.mapToGlobal(core.Point())
        with gui.Painter(image) as painter:
            painter.set_composition_mode("source_atop")
            painter.drawImage(d, gl_widget.grabFramebuffer())
    return image

get_modality() -> constants.ModalityStr

Get the current modality modes as a string.

Returns:

Type Description
constants.ModalityStr

modality mode

Source code in prettyqt\widgets\widget.py
def get_modality(self) -> constants.ModalityStr:
    """Get the current modality modes as a string.

    Returns:
        modality mode
    """
    return constants.MODALITY.inverse[self.windowModality()]

get_palette() -> gui.Palette

Source code in prettyqt\widgets\widget.py
def get_palette(self) -> gui.Palette:
    return gui.Palette(self.palette())

get_screen() -> gui.Screen | None

Source code in prettyqt\widgets\widget.py
def get_screen(self) -> gui.Screen | None:
    window = self.window().windowHandle()
    return None if window is None else gui.Screen(window.screen())

get_size_policy() -> widgets.SizePolicy

Source code in prettyqt\widgets\widget.py
def get_size_policy(self) -> widgets.SizePolicy:
    qpol = self.sizePolicy()
    if isinstance(qpol, widgets.SizePolicy):
        return qpol
    return widgets.SizePolicy.clone(qpol)

get_stylesheet() -> qstylizer.style.StyleSheet

Source code in prettyqt\widgets\widget.py
def get_stylesheet(self) -> qstylizer.style.StyleSheet:
    try:
        return qstylizer.parser.parse(self.styleSheet())
    except ValueError:
        return qstylizer.style.StyleSheet()

get_title() -> str

Source code in prettyqt\widgets\widget.py
def get_title(self) -> str:
    return self.windowTitle()

get_window_file_path() -> pathlib.Path | None

Source code in prettyqt\widgets\widget.py
def get_window_file_path(self) -> pathlib.Path | None:
    path = self.windowFilePath()
    return pathlib.Path(path) if path else None

get_window_state() -> constants.WindowStateStr

Return current window state.

Returns:

Type Description
constants.WindowStateStr

window state

Source code in prettyqt\widgets\widget.py
def get_window_state(self) -> constants.WindowStateStr:
    """Return current window state.

    Returns:
        window state
    """
    return constants.WINDOW_STATES.inverse[self.windowState()]

grab_keyboard_events() -> Iterator[None]

Source code in prettyqt\widgets\widget.py
@contextlib.contextmanager
def grab_keyboard_events(self) -> Iterator[None]:
    self.grabKeyboard()
    yield None
    self.releaseKeyboard()

grab_mouse_events(cursor_shape: constants.CursorShapeStr | None = None) -> Iterator[None]

Source code in prettyqt\widgets\widget.py
@contextlib.contextmanager
def grab_mouse_events(
    self, cursor_shape: constants.CursorShapeStr | None = None
) -> Iterator[None]:
    if cursor_shape is not None:
        self.grabMouse(constants.CURSOR_SHAPE[cursor_shape])
    else:
        self.grabMouse()
    yield None
    self.releaseMouse()

raise_dock() -> bool

Source code in prettyqt\widgets\widget.py
def raise_dock(self) -> bool:
    w = self.find_parent(QtWidgets.QDockWidget)
    if w is None:
        return False
    w.setVisible(True)
    w.raise_()
    return True

raise_to_top()

Source code in prettyqt\widgets\widget.py
def raise_to_top(self):
    if sys.platform.startswith("win"):
        import win32con
        from win32gui import SetWindowPos

        # set to always-on-top and disable it again. that way windows stays in front
        flag = win32con.SWP_NOMOVE | win32con.SWP_NOSIZE | win32con.SWP_SHOWWINDOW
        win_id = self.winId()
        SetWindowPos(win_id, win32con.HWND_TOPMOST, 0, 0, 0, 0, flag)
        SetWindowPos(win_id, win32con.HWND_NOTOPMOST, 0, 0, 0, 0, flag)
    # state = (self.windowState() & ~Qt.WindowMinimized) | Qt.WindowActive
    # self.setWindowState(state)
    self.raise_()
    self.show()
    self.activateWindow()

resize(*size) -> None

Source code in prettyqt\widgets\widget.py
def resize(self, *size) -> None:
    if isinstance(size[0], tuple):
        super().resize(*size[0])
    else:
        super().resize(*size)

set_attribute(attribute: constants.WidgetAttributeStr, state: bool = True) -> None

Source code in prettyqt\widgets\widget.py
def set_attribute(
    self, attribute: constants.WidgetAttributeStr, state: bool = True
) -> None:
    if attribute not in constants.WIDGET_ATTRIBUTE:
        raise InvalidParamError(attribute, constants.WIDGET_ATTRIBUTE)
    self.setAttribute(constants.WIDGET_ATTRIBUTE[attribute], state)

set_attributes(**kwargs: bool) -> None

Source code in prettyqt\widgets\widget.py
def set_attributes(self, **kwargs: bool) -> None:
    for attr, state in kwargs.items():
        if attr not in constants.WIDGET_ATTRIBUTE:
            raise InvalidParamError(attr, constants.WIDGET_ATTRIBUTE)
        self.setAttribute(constants.WIDGET_ATTRIBUTE[attr], state)  # type: ignore

set_background_color(color: datatypes.ColorType) -> None

Source code in prettyqt\widgets\widget.py
def set_background_color(self, color: datatypes.ColorType) -> None:
    col_str = "" if color is None else colors.get_color(color).name()
    with self.edit_stylesheet() as ss:
        ss.backgroundColor.setValue(col_str)

set_background_role(role: gui.palette.RoleStr)

Source code in prettyqt\widgets\widget.py
def set_background_role(self, role: gui.palette.RoleStr):
    if role not in gui.palette.ROLE:
        raise InvalidParamError(role, gui.palette.ROLE)
    self.setBackgroundRole(gui.palette.ROLE[role])

set_context_menu_policy(policy: constants.ContextPolicyStr) -> None

Set contextmenu policy for given item view.

Parameters:

Name Type Description Default
policy constants.ContextPolicyStr

contextmenu policy to use

required

Raises:

Type Description
InvalidParamError

policy does not exist

Source code in prettyqt\widgets\widget.py
def set_context_menu_policy(self, policy: constants.ContextPolicyStr) -> None:
    """Set contextmenu policy for given item view.

    Args:
        policy: contextmenu policy to use

    Raises:
        InvalidParamError: policy does not exist
    """
    if policy not in constants.CONTEXT_POLICY:
        raise InvalidParamError(policy, constants.CONTEXT_POLICY)
    self.setContextMenuPolicy(constants.CONTEXT_POLICY[policy])

set_contextmenu_policy(policy: constants.ContextPolicyStr) -> None

Source code in prettyqt\widgets\widget.py
@deprecated(reason="This method is deprecated, use set_context_menu_policy instead.")
def set_contextmenu_policy(self, policy: constants.ContextPolicyStr) -> None:
    return self.set_context_menu_policy(policy)

set_cursor(cursor: constants.CursorShapeStr | QtGui.QCursor) -> None

Source code in prettyqt\widgets\widget.py
def set_cursor(self, cursor: constants.CursorShapeStr | QtGui.QCursor) -> None:
    if isinstance(cursor, QtGui.QCursor):
        curs = cursor
    elif cursor in constants.CURSOR_SHAPE:
        curs = gui.Cursor(constants.CURSOR_SHAPE[cursor])
    else:
        raise InvalidParamError(cursor, constants.CURSOR_SHAPE)
    self.setCursor(curs)

set_custom_menu(method: Callable) -> None

Source code in prettyqt\widgets\widget.py
def set_custom_menu(self, method: Callable) -> None:
    self.set_context_menu_policy("custom")
    self.customContextMenuRequested.connect(method)

set_disabled() -> None

Source code in prettyqt\widgets\widget.py
def set_disabled(self) -> None:
    self.setEnabled(False)

set_enabled(enabled: bool = True) -> None

Source code in prettyqt\widgets\widget.py
def set_enabled(self, enabled: bool = True) -> None:
    self.setEnabled(enabled)

set_flags(minimize: bool | None = None, maximize: bool | None = None, close: bool | None = None, stay_on_top: bool | None = None, frameless: bool | None = None, window: bool | None = None, dialog: bool | None = None, tooltip: bool | None = None, tool: bool | None = None, customize: bool | None = None, window_title: bool | None = None) -> None

Source code in prettyqt\widgets\widget.py
def set_flags(
    self,
    minimize: bool | None = None,
    maximize: bool | None = None,
    close: bool | None = None,
    stay_on_top: bool | None = None,
    frameless: bool | None = None,
    window: bool | None = None,
    dialog: bool | None = None,
    tooltip: bool | None = None,
    tool: bool | None = None,
    customize: bool | None = None,
    window_title: bool | None = None,
) -> None:
    flags = {
        minimize: QtCore.Qt.WindowType.WindowMinimizeButtonHint,
        maximize: QtCore.Qt.WindowType.WindowMaximizeButtonHint,
        close: QtCore.Qt.WindowType.WindowCloseButtonHint,
        stay_on_top: QtCore.Qt.WindowType.WindowStaysOnTopHint,
        frameless: QtCore.Qt.WindowType.FramelessWindowHint,
        window: QtCore.Qt.WindowType.Window,
        dialog: QtCore.Qt.WindowType.Dialog,
        tooltip: QtCore.Qt.WindowType.ToolTip,
        tool: QtCore.Qt.WindowType.Tool,
        customize: QtCore.Qt.WindowType.CustomizeWindowHint,
        window_title: QtCore.Qt.WindowType.WindowTitleHint,
    }
    for k, v in flags.items():
        if k is not None:
            self.setWindowFlag(v, k)

set_focus_policy(policy: constants.FocusPolicyStr) -> None

Set the way the widget accepts keyboard focus.

Parameters:

Name Type Description Default
policy str

Focus policy

required

Raises:

Type Description
InvalidParamError

Description

Source code in prettyqt\widgets\widget.py
def set_focus_policy(self, policy: constants.FocusPolicyStr) -> None:
    """Set the way the widget accepts keyboard focus.

    Args:
        policy (str): Focus policy

    Raises:
        InvalidParamError: Description
    """
    if policy not in constants.FOCUS_POLICY:
        raise InvalidParamError(policy, constants.FOCUS_POLICY)
    self.setFocusPolicy(constants.FOCUS_POLICY[policy])

set_font(font_name: str | None = None, font_size: int | None = None, weight: int | None = None, italic: bool = False) -> gui.Font

Source code in prettyqt\widgets\widget.py
def set_font(
    self,
    font_name: str | None = None,
    font_size: int | None = None,
    weight: int | None = None,
    italic: bool = False,
) -> gui.Font:
    if font_size is None:
        font_size = -1
    if weight is None:
        weight = -1
    if font_name is None:
        font_name = self.font().family()
    font = gui.Font(font_name, font_size, weight, italic)
    self.setFont(font)
    return font

set_font_size(size: int) -> None

Source code in prettyqt\widgets\widget.py
def set_font_size(self, size: int) -> None:
    font = self.font()
    font.setPointSize(size)
    self.setFont(font)

set_foreground_role(role: gui.palette.RoleStr)

Source code in prettyqt\widgets\widget.py
def set_foreground_role(self, role: gui.palette.RoleStr):
    if role not in gui.palette.ROLE:
        raise InvalidParamError(role, gui.palette.ROLE)
    self.setForegroundRole(gui.palette.ROLE[role])

set_icon(icon: datatypes.IconType) -> None

Set the window icon.

Parameters:

Name Type Description Default
icon datatypes.IconType

icon to use

required
Source code in prettyqt\widgets\widget.py
def set_icon(self, icon: datatypes.IconType) -> None:
    """Set the window icon.

    Args:
        icon: icon to use
    """
    icon = iconprovider.get_icon(icon, color=colors.WINDOW_ICON_COLOR)
    self.setWindowIcon(icon)

set_layout(layout: LayoutStr | QtWidgets.QLayout | None, margin: int | None = None, spacing: int | None = None)

Source code in prettyqt\widgets\widget.py
def set_layout(
    self,
    layout: LayoutStr | QtWidgets.QLayout | None,
    margin: int | None = None,
    spacing: int | None = None,
):
    if layout is None:
        return
    match layout:
        case "horizontal" | "vertical":
            self.box = widgets.BoxLayout(layout)
        case "grid":
            self.box = widgets.GridLayout()
        case "form":
            self.box = widgets.FormLayout()
        case "stacked":
            self.box = widgets.StackedLayout()
        case "flow":
            from prettyqt import custom_widgets

            self.box = custom_widgets.FlowLayout()
        case QtWidgets.QLayout():
            self.box = layout
        case _:
            raise ValueError("Invalid Layout")
    self.setLayout(self.box)
    if margin is not None:
        self.box.set_margin(margin)
    if spacing is not None:
        self.box.setSpacing(spacing)

set_margin(margin: int) -> None

Source code in prettyqt\widgets\widget.py
def set_margin(self, margin: int) -> None:
    self.setContentsMargins(margin, margin, margin, margin)

set_mask(area: datatypes.RectType | QtGui.QRegion | None, typ: gui.region.RegionTypeStr = 'rectangle')

Source code in prettyqt\widgets\widget.py
def set_mask(
    self,
    area: datatypes.RectType | QtGui.QRegion | None,
    typ: gui.region.RegionTypeStr = "rectangle",
):
    match area:
        case None:
            self.clearMask()
            return
        case tuple():
            area = gui.Region(*area, gui.region.REGION_TYPE[typ])
        case QtCore.QRect():
            area = gui.Region(area, gui.region.REGION_TYPE[typ])
    self.setMask(area)

set_max_height(height: int | None) -> None

Source code in prettyqt\widgets\widget.py
def set_max_height(self, height: int | None) -> None:
    if height is None:
        height = QWIDGETSIZE_MAX
    self.setMaximumHeight(height)

set_max_size(size: QtCore.QSize | tuple[int | None, int | None]) -> None

Source code in prettyqt\widgets\widget.py
@functools.singledispatchmethod
def set_max_size(self, size: QtCore.QSize | tuple[int | None, int | None]) -> None:
    if isinstance(size, tuple):
        x = QWIDGETSIZE_MAX if size[0] is None else size[0]
        y = QWIDGETSIZE_MAX if size[1] is None else size[1]
        self.setMaximumSize(x, y)
    else:
        self.setMaximumSize(size)

set_max_width(width: int | None) -> None

Source code in prettyqt\widgets\widget.py
def set_max_width(self, width: int | None) -> None:
    if width is None:
        width = QWIDGETSIZE_MAX
    self.setMaximumWidth(width)

set_min_height(height: int | None) -> None

Source code in prettyqt\widgets\widget.py
def set_min_height(self, height: int | None) -> None:
    if height is None:
        height = 0
    self.setMinimumHeight(height)

set_min_size(size: QtCore.QSize | tuple[int | None, int | None]) -> None

Source code in prettyqt\widgets\widget.py
@functools.singledispatchmethod
def set_min_size(self, size: QtCore.QSize | tuple[int | None, int | None]) -> None:
    if isinstance(size, tuple):
        x = 0 if size[0] is None else size[0]
        y = 0 if size[1] is None else size[1]
        self.setMinimumSize(x, y)
    else:
        self.setMinimumSize(size)

set_min_width(width: int | None) -> None

Source code in prettyqt\widgets\widget.py
def set_min_width(self, width: int | None) -> None:
    if width is None:
        width = 0
    self.setMinimumWidth(width)

set_modality(modality: constants.ModalityStr) -> None

Set modality for the dialog.

Parameters:

Name Type Description Default
modality constants.ModalityStr

modality for the main window

required

Raises:

Type Description
InvalidParamError

modality type does not exist

Source code in prettyqt\widgets\widget.py
def set_modality(self, modality: constants.ModalityStr) -> None:
    """Set modality for the dialog.

    Args:
        modality: modality for the main window

    Raises:
        InvalidParamError: modality type does not exist
    """
    if modality not in constants.MODALITY:
        raise InvalidParamError(modality, constants.MODALITY)
    self.setWindowModality(constants.MODALITY[modality])

set_size_policy(horizontal: widgets.sizepolicy.SizePolicyStr | None = None, vertical: widgets.sizepolicy.SizePolicyStr | None = None) -> None

Set the sizes policy.

Parameters:

Name Type Description Default
horizontal widgets.sizepolicy.SizePolicyStr | None

horizontal size policy

None
vertical widgets.sizepolicy.SizePolicyStr | None

vertical size policy

None
Source code in prettyqt\widgets\widget.py
def set_size_policy(
    self,
    horizontal: widgets.sizepolicy.SizePolicyStr | None = None,
    vertical: widgets.sizepolicy.SizePolicyStr | None = None,
) -> None:
    """Set the sizes policy.

    Args:
        horizontal: horizontal size policy
        vertical: vertical size policy
    """
    sp = self.get_size_policy()
    if horizontal is not None:
        sp.set_horizontal_policy(horizontal)
    if vertical is not None:
        sp.set_vertical_policy(vertical)
    self.setSizePolicy(sp)

set_stylesheet(ss: None | str | qstylizer.style.StyleSheet | datatypes.PathType)

Source code in prettyqt\widgets\widget.py
def set_stylesheet(
    self, ss: None | str | qstylizer.style.StyleSheet | datatypes.PathType
):
    match ss:
        case None:
            ss = ""
        case os.PathLike():
            ss = pathlib.Path(ss).read_text()
        case qstylizer.style.StyleSheet():
            ss = str(ss)
    self.setStyleSheet(ss)

set_title(title: str) -> None

Source code in prettyqt\widgets\widget.py
def set_title(self, title: str) -> None:
    self.setWindowTitle(title)

set_tooltip(tooltip: str | datatypes.PathType, size: datatypes.SizeType | None = None)

Source code in prettyqt\widgets\widget.py
def set_tooltip(
    self,
    tooltip: str | datatypes.PathType,
    size: datatypes.SizeType | None = None,
):
    if isinstance(tooltip, os.PathLike):
        path = os.fspath(tooltip)
        if size is None:
            tooltip = f"<img src={path!r}>"
        else:
            if isinstance(size, QtCore.QSize):
                size = (size.width(), size.height())
            tooltip = f'<img src={path!r} width="{size[0]}" height="{size[1]}">'
    self.setToolTip(tooltip)

set_window_file_path(path: datatypes.PathType)

Source code in prettyqt\widgets\widget.py
def set_window_file_path(self, path: datatypes.PathType):
    self.setWindowFilePath(os.fspath(path))

set_window_flags(*flags: constants.WindowFlagStr, append: bool = False)

Source code in prettyqt\widgets\widget.py
def set_window_flags(self, *flags: constants.WindowFlagStr, append: bool = False):
    for flag in flags:
        if flag not in constants.WINDOW_FLAGS:
            raise InvalidParamError(flag, constants.WINDOW_FLAGS)
    result = helpers.merge_flags(flags, constants.WINDOW_FLAGS)
    if append:
        result = result | self.windowFlags()
    self.setWindowFlags(result)

set_window_state(policy: constants.WindowStateStr) -> None

Set window state for given item view.

Parameters:

Name Type Description Default
policy constants.WindowStateStr

window state to use

required

Raises:

Type Description
InvalidParamError

policy does not exist

Source code in prettyqt\widgets\widget.py
def set_window_state(self, policy: constants.WindowStateStr) -> None:
    """Set window state for given item view.

    Args:
        policy: window state to use

    Raises:
        InvalidParamError: policy does not exist
    """
    if policy not in constants.WINDOW_STATES:
        raise InvalidParamError(policy, constants.WINDOW_STATES)
    self.setWindowState(constants.WINDOW_STATES[policy])

toggle_fullscreen()

Toggle between fullscreen and regular size.

Source code in prettyqt\widgets\widget.py
def toggle_fullscreen(self):
    """Toggle between fullscreen and regular size."""
    if self.isFullScreen():
        self.showNormal()
    else:
        self.showFullScreen()

toggle_maximized()

Toggle between maximized and regular size.

Source code in prettyqt\widgets\widget.py
def toggle_maximized(self):
    """Toggle between maximized and regular size."""
    if self.isMaximized():
        self.showNormal()
    else:
        self.showMaximized()

updates_off() -> Iterator[None]

Source code in prettyqt\widgets\widget.py
@contextlib.contextmanager
def updates_off(self) -> Iterator[None]:
    updates = self.updatesEnabled()
    self.setUpdatesEnabled(False)
    yield None
    self.setUpdatesEnabled(updates)

Wizard

Bases: WizardMixin, QtWidgets.QWizard

Source code in prettyqt\widgets\wizard.py
class Wizard(WizardMixin, QtWidgets.QWizard):
    pass

WizardPage

Bases: WizardPageMixin, QtWidgets.QWizardPage

Source code in prettyqt\widgets\wizardpage.py
class WizardPage(WizardPageMixin, QtWidgets.QWizardPage):
    pass

app(args: list[str] | None = None) -> Application

Source code in prettyqt\widgets\__init__.py
def app(args: list[str] | None = None) -> Application:
    if (instance := Application.instance()) is not None:
        return instance
    Application.disable_window_help_button()
    #  + ["--ignore-gpu-blacklist", "--enable-gpu-rasterization"]
    return Application(sys.argv if args is None else args)